const guchar *text,
gint length,
gchar ***list);
+gint gdk_text_property_to_utf8_list (GdkAtom encoding,
+ gint format,
+ const guchar *text,
+ gint length,
+ gchar ***list);
+
+gchar *gdk_utf8_to_string_target (const gchar *str);
+gboolean gdk_utf8_to_compound_text (const gchar *str,
+ GdkAtom *encoding,
+ gint *format,
+ guchar **ctext,
+ gint *length);
+
void gdk_free_text_list (gchar **list);
gint gdk_string_to_compound_text (const gchar *str,
GdkAtom *encoding,
GDK_NOTE (EVENTS,
g_message ("selection clear:\twindow: %ld",
xevent->xproperty.window));
-
- event->selection.type = GDK_SELECTION_CLEAR;
- event->selection.window = window;
- event->selection.selection = xevent->xselectionclear.selection;
- event->selection.time = xevent->xselectionclear.time;
-
+
+ if (_gdk_selection_filter_clear_event (&xevent->xselectionclear))
+ {
+ event->selection.type = GDK_SELECTION_CLEAR;
+ event->selection.window = window;
+ event->selection.selection = xevent->xselectionclear.selection;
+ event->selection.time = xevent->xselectionclear.time;
+ }
+ else
+ return_val = FALSE;
+
break;
case SelectionRequest:
XSync (gdk_display, False);
}
+static GdkAtom timestamp_prop_atom = 0;
+
+static Bool
+timestamp_predicate (Display *display,
+ XEvent *xevent,
+ XPointer arg)
+{
+ Window xwindow = GPOINTER_TO_UINT (arg);
+
+ if (xevent->type == PropertyNotify &&
+ xevent->xproperty.window == xwindow &&
+ xevent->xproperty.atom == timestamp_prop_atom)
+ return True;
+
+ return False;
+}
+
+/**
+ * gdk_x11_get_server_time:
+ * @window: a #GdkWindow, used for communication with the server.
+ * The window must have GDK_PROPERTY_CHANGE_MASK in its
+ * events mask or a hang will result.
+ *
+ * Routine to get the current X server time stamp.
+ *
+ * Return value: the time stamp.
+ **/
+guint32
+gdk_x11_get_server_time (GdkWindow *window)
+{
+ Display *xdisplay;
+ Window xwindow;
+ guchar c = 'a';
+ XEvent xevent;
+
+ g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
+ g_return_val_if_fail (!GDK_WINDOW_DESTROYED (window), 0);
+
+ if (!timestamp_prop_atom)
+ timestamp_prop_atom = gdk_atom_intern ("GDK_TIMESTAMP_PROP", FALSE);
+
+ xdisplay = GDK_WINDOW_XDISPLAY (window);
+ xwindow = GDK_WINDOW_XWINDOW (window);
+
+ XChangeProperty (xdisplay, xwindow,
+ timestamp_prop_atom, timestamp_prop_atom,
+ 8, PropModeReplace, &c, 1);
+
+ XIfEvent (xdisplay, &xevent,
+ timestamp_predicate, GUINT_TO_POINTER(xwindow));
+
+ return xevent.xproperty.time;
+}
gulong serial,
GdkRectangle *area);
+void _gdk_selection_window_destroyed (GdkWindow *window);
+gboolean _gdk_selection_filter_clear_event (XSelectionClearEvent *event);
+
extern GdkDrawableClass _gdk_x11_drawable_class;
extern gboolean gdk_use_xshm;
extern Atom gdk_wm_delete_window;
extern Atom gdk_wm_take_focus;
extern Atom gdk_wm_protocols;
extern Atom gdk_wm_window_protocols[];
-extern GdkWindow *selection_owner[];
extern gboolean gdk_null_window_warnings;
extern const int gdk_nevent_masks;
extern const int gdk_event_mask_table[];
#endif /* __GDK_PRIVATE_X11_H__ */
-
-
#include "gdkprivate.h"
#include "gdkprivate-x11.h"
+typedef struct _OwnerInfo OwnerInfo;
+
+struct _OwnerInfo
+{
+ GdkAtom selection;
+ GdkWindow *owner;
+ gulong serial;
+};
+
+GSList *owner_list;
+
+/* When a window is destroyed we check if it is the owner
+ * of any selections. This is somewhat inefficient, but
+ * owner_list is typically short, and it is a low memory,
+ * low code solution
+ */
+void
+_gdk_selection_window_destroyed (GdkWindow *window)
+{
+ GSList *tmp_list = owner_list;
+ while (tmp_list)
+ {
+ OwnerInfo *info = tmp_list->data;
+ if (info->owner == window)
+ {
+ owner_list = g_slist_remove (owner_list, info);
+ g_free (info);
+ }
+ tmp_list = tmp_list->next;
+ }
+}
+
+/* We only pass through those SelectionClear events that actually
+ * reflect changes to the selection owner that we didn't make ourself.
+ */
+gboolean
+_gdk_selection_filter_clear_event (XSelectionClearEvent *event)
+{
+ GSList *tmp_list = owner_list;
+
+ while (tmp_list)
+ {
+ OwnerInfo *info = tmp_list->data;
+ if (info->selection == event->selection)
+ {
+ if ((GDK_DRAWABLE_XID (info->owner) == event->window &&
+ event->serial >= info->serial))
+ {
+ owner_list = g_slist_remove (owner_list, info);
+ g_free (info);
+ return TRUE;
+ }
+ else
+ return FALSE;
+ }
+ tmp_list = tmp_list->next;
+ }
+
+ return FALSE;
+}
gboolean
gdk_selection_owner_set (GdkWindow *owner,
{
Display *xdisplay;
Window xwindow;
+ GSList *tmp_list;
+ OwnerInfo *info;
if (owner)
{
xdisplay = gdk_display;
xwindow = None;
}
+
+ tmp_list = owner_list;
+ while (tmp_list)
+ {
+ info = tmp_list->data;
+ if (info->selection == selection)
+ {
+ owner_list = g_slist_remove (owner_list, info);
+ g_free (info);
+ break;
+ }
+ tmp_list = tmp_list->next;
+ }
+
+ if (owner)
+ {
+ info = g_new (OwnerInfo, 1);
+ info->owner = owner;
+ info->serial = NextRequest (GDK_WINDOW_XDISPLAY (owner));
+ info->selection = selection;
+
+ owner_list = g_slist_prepend (owner_list, info);
+ }
XSetSelectionOwner (xdisplay, selection, xwindow, time);
XFreeStringList (list);
}
+static gint
+make_list (const gchar *text,
+ gint length,
+ gboolean latin1,
+ gchar ***list)
+{
+ GSList *strings = NULL;
+ gint n_strings = 0;
+ gint i;
+ const gchar *p = text;
+ const gchar *q;
+ GSList *tmp_list;
+ GError *error = NULL;
+
+ while (p < text + length)
+ {
+ gchar *str;
+
+ q = p;
+ while (*q && q < text + length)
+ q++;
+
+ if (latin1)
+ {
+ str = g_convert (p, q - p,
+ "UTF-8", "ISO-8859-1",
+ NULL, NULL, &error);
+
+ if (!str)
+ {
+ g_warning ("Error converting selection from STRING: %s",
+ error->message);
+ g_error_free (error);
+ }
+ }
+ else
+ str = g_strndup (p, q - p);
+
+ if (str)
+ {
+ strings = g_slist_prepend (strings, str);
+ n_strings++;
+ }
+
+ p = q + 1;
+ }
+
+ if (list)
+ *list = g_new (gchar *, n_strings + 1);
+
+ (*list)[n_strings] = NULL;
+
+ i = n_strings;
+ tmp_list = strings;
+ while (tmp_list)
+ {
+ if (list)
+ (*list)[--i] = tmp_list->data;
+ else
+ g_free (tmp_list->data);
+
+ tmp_list = tmp_list->next;
+ }
+
+ g_slist_free (strings);
+
+ return n_strings;
+}
+
+/**
+ * gdk_text_property_to_utf8_list:
+ * @encoding: an atom representing the encoding of the text
+ * @format: the format of the property
+ * @text: the text to convert
+ * @length: the length of @text, in bytes
+ * @list: location to store the list of strings or %NULL. The
+ * list should be freed with g_strfreev().
+ *
+ * Convert a text property in the giving encoding to
+ * a list of UTF-8 strings.
+ *
+ * Return value: the number of strings in the resulting
+ * list.
+ **/
+gint
+gdk_text_property_to_utf8_list (GdkAtom encoding,
+ gint format,
+ const guchar *text,
+ gint length,
+ gchar ***list)
+{
+ g_return_val_if_fail (text != NULL, 0);
+ g_return_val_if_fail (length >= 0, 0);
+
+ if (encoding == GDK_TARGET_STRING)
+ {
+ return make_list ((gchar *)text, length, TRUE, list);
+ }
+ else if (encoding == gdk_atom_intern ("UTF8_STRING", FALSE))
+ {
+ return make_list ((gchar *)text, length, FALSE, list);
+ }
+ else
+ {
+ gchar **local_list;
+ gint local_count;
+ gint i;
+ gchar *charset = NULL;
+ gboolean need_conversion= g_get_charset (&charset);
+ gint count = 0;
+ GError *error = NULL;
+
+ /* Probably COMPOUND text, we fall back to Xlib routines
+ */
+ local_count = gdk_text_property_to_text_list (encoding,
+ format,
+ text,
+ length,
+ &local_list);
+ if (list)
+ *list = g_new (gchar *, local_count + 1);
+
+ for (i=0; i<local_count; i++)
+ {
+ /* list contains stuff in our default encoding
+ */
+ if (need_conversion)
+ {
+ gchar *utf = g_convert (local_list[i], -1,
+ "UTF-8", charset,
+ NULL, NULL, &error);
+ if (utf)
+ {
+ if (list)
+ (*list)[count++] = utf;
+ else
+ g_free (utf);
+ }
+ else
+ {
+ g_warning ("Error converting to UTF-8 from '%s': %s",
+ charset, error->message);
+ g_error_free (error);
+ error = NULL;
+ }
+ }
+ else
+ {
+ if (list)
+ (*list)[count++] = g_strdup (local_list[i]);
+ }
+ }
+
+ gdk_free_text_list (local_list);
+ (*list)[count] = NULL;
+
+ return count;
+ }
+}
+
gint
gdk_string_to_compound_text (const gchar *str,
GdkAtom *encoding,
return res;
}
+/* The specifications for COMPOUND_TEXT and STRING specify that C0 and
+ * C1 are not allowed except for \n and \t, however the X conversions
+ * routines for COMPOUND_TEXT only enforce this in one direction,
+ * causing cut-and-paste of \r and \r\n separated text to fail.
+ * This routine strips out all non-allowed C0 and C1 characters
+ * from the input string and also canonicalizes \r, \r\n, and \n\r to \n
+ */
+static gchar *
+sanitize_utf8 (const gchar *src)
+{
+ gint len = strlen (src);
+ GString *result = g_string_sized_new (len);
+ const gchar *p = src;
+
+ while (*p)
+ {
+ if (*p == '\r' || *p == '\n')
+ {
+ p++;
+ if (*p == '\r' || *p == '\n')
+ p++;
+
+ g_string_append_c (result, '\n');
+ }
+ else
+ {
+ gunichar ch = g_utf8_get_char (p);
+ char buf[7];
+ gint buflen;
+
+ if (!((ch < 0x20 && ch != '\t') || (ch >= 0x7f && ch < 0xa0)))
+ {
+ buflen = g_unichar_to_utf8 (ch, buf);
+ g_string_append_len (result, buf, buflen);
+ }
+
+ p = g_utf8_next_char (p);
+ }
+ }
+
+ return g_string_free (result, FALSE);
+}
+
+/**
+ * gdk_utf8_to_string_target:
+ * @str: a UTF-8 string
+ *
+ * Convert an UTF-8 string into the best possible representation
+ * as a STRING. The representation of characters not in STRING
+ * is not specified; it may be as pseudo-escape sequences
+ * \x{ABCD}, or it may be in some other form of approximation.
+ *
+ * Return value: the newly allocated string, or %NULL if the
+ * conversion failed. (It should not fail for
+ * any properly formed UTF-8 string.)
+ **/
+gchar *
+gdk_utf8_to_string_target (const gchar *str)
+{
+ GError *error = NULL;
+
+ gchar *tmp_str = sanitize_utf8 (str);
+ gchar *result = g_convert_with_fallback (tmp_str, -1,
+ "ISO-8859-1", "UTF-8",
+ NULL, NULL, NULL, &error);
+ if (!result)
+ {
+ g_warning ("Error converting from UTF-8 to STRING: %s",
+ error->message);
+ g_error_free (error);
+ }
+
+ g_free (tmp_str);
+ return result;
+}
+
+/**
+ * gdk_utf8_to_compound_text:
+ * @str: a UTF-8 string
+ * @encoding: location to store resulting encoding
+ * @format: location to store format of the result
+ * @ctext: location to store the data of the result
+ * @length: location to store the length of the data
+ * stored in @ctext
+ *
+ * Convert from UTF-8 to compound text.
+ *
+ * Return value: %TRUE if the conversion succeeded, otherwise
+ * false.
+ **/
+gboolean
+gdk_utf8_to_compound_text (const gchar *str,
+ GdkAtom *encoding,
+ gint *format,
+ guchar **ctext,
+ gint *length)
+{
+ gboolean need_conversion;
+ gchar *charset;
+ gchar *locale_str, *tmp_str;
+ GError *error = NULL;
+ gboolean result;
+
+ g_return_val_if_fail (str != NULL, FALSE);
+
+ need_conversion = g_get_charset (&charset);
+
+ tmp_str = sanitize_utf8 (str);
+
+ if (need_conversion)
+ {
+ locale_str = g_convert_with_fallback (tmp_str, -1,
+ charset, "UTF-8",
+ NULL, NULL, NULL, &error);
+ g_free (tmp_str);
+
+ if (!locale_str)
+ {
+ g_warning ("Error converting from UTF-8 to '%s': %s",
+ charset, error->message);
+ g_error_free (error);
+
+ if (encoding)
+ *encoding = None;
+ if (format)
+ *format = None;
+ if (ctext)
+ *ctext = NULL;
+ if (length)
+ *length = 0;
+
+ return FALSE;
+ }
+ }
+ else
+ locale_str = tmp_str;
+
+ result = gdk_string_to_compound_text (locale_str,
+ encoding, format, ctext, length);
+
+ g_free (locale_str);
+
+ return result;
+}
+
void gdk_free_compound_text (guchar *ctext)
{
if (ctext)
GdkWindowObject *private = (GdkWindowObject *)window;
g_return_if_fail (GDK_IS_WINDOW (window));
+
+ _gdk_selection_window_destroyed (window);
if (private->extension_events != 0)
gdk_input_window_destroy (window);
/* Return the Gdk* for a particular XID */
gpointer gdk_xid_table_lookup (XID xid);
+guint32 gdk_x11_get_server_time (GdkWindow *window);
+
#define gdk_window_lookup(xid) ((GdkWindow*) gdk_xid_table_lookup (xid))
#define gdk_pixmap_lookup(xid) ((GdkPixmap*) gdk_xid_table_lookup (xid))
#define gdk_font_lookup(xid) ((GdkFont*) gdk_xid_table_lookup (xid))
--- /dev/null
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2000 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Global clipboard abstraction.
+ */
+
+#include <string.h>
+
+#include "gtkclipboard.h"
+#include "gtkinvisible.h"
+#include "gtkmain.h"
+#include "gtksignal.h"
+
+#ifdef GDK_WINDOWING_X11
+#include "x11/gdkx.h"
+#endif
+
+typedef struct _RequestContentsInfo RequestContentsInfo;
+typedef struct _RequestTextInfo RequestTextInfo;
+
+struct _GtkClipboard
+{
+ GdkAtom selection;
+
+ GtkClipboardGetFunc get_func;
+ GtkClipboardClearFunc clear_func;
+ gpointer user_data;
+ gboolean have_owner;
+
+ guint32 timestamp;
+
+ gboolean have_selection;
+};
+
+struct _RequestContentsInfo
+{
+ GtkClipboardReceivedFunc callback;
+ gpointer user_data;
+};
+
+struct _RequestTextInfo
+{
+ GtkClipboardTextReceivedFunc callback;
+ gpointer user_data;
+};
+
+static void clipboard_unset (GtkClipboard *clipboard);
+static void selection_received (GtkWidget *widget,
+ GtkSelectionData *selection_data,
+ guint time);
+
+static GSList *clipboards;
+static GtkWidget *clipboard_widget;
+
+enum {
+ TARGET_STRING,
+ TARGET_TEXT,
+ TARGET_COMPOUND_TEXT,
+ TARGET_UTF8_STRING
+};
+
+static const gchar *request_contents_key = "gtk-request-contents";
+static GQuark request_contents_key_id = 0;
+
+static const gchar *clipboards_owned_key = "gtk-clipboards-owned";
+static GQuark clipboards_owned_key_id = 0;
+
+
+/**
+ * gtk_clipboard_get:
+ * @selection: a #GdkAtom which identifies the clipboard
+ * to use. A value of GDK_NONE here is the
+ * same as gdk_atom_intern ("CLIPBOARD", FALSE),
+ * and provides the default clipboard. Another
+ * common value is GDK_SELECTION_PRIMARY, which
+ * identifies the primary X selection.
+ *
+ * Returns the clipboard object for the given selection.
+ *
+ * Return value: the appropriate clipboard object. If no
+ * clipboard already exists, a new one will
+ * be created. Once a clipboard object has
+ * been created, it is persistant for all time.
+ **/
+GtkClipboard *
+gtk_clipboard_get (GdkAtom selection)
+{
+ GtkClipboard *clipboard = NULL;
+ GSList *tmp_list;
+
+ if (selection == GDK_NONE)
+ selection = gdk_atom_intern ("CLIPBOARD", FALSE);
+
+ tmp_list = clipboards;
+ while (tmp_list)
+ {
+ clipboard = tmp_list->data;
+ if (clipboard->selection == selection)
+ break;
+
+ tmp_list = tmp_list->next;
+ }
+
+ if (!tmp_list)
+ {
+ clipboard = g_new0 (GtkClipboard, 1);
+ clipboard->selection = selection;
+ clipboards = g_slist_prepend (clipboards, clipboard);
+ }
+
+ return clipboard;
+}
+
+static void
+selection_get_cb (GtkWidget *widget,
+ GtkSelectionData *selection_data,
+ guint time,
+ guint info)
+{
+ GtkClipboard *clipboard = gtk_clipboard_get (selection_data->selection);
+
+ if (clipboard && clipboard->get_func)
+ clipboard->get_func (clipboard, selection_data, info, clipboard->user_data);
+}
+
+static gboolean
+selection_clear_event_cb (GtkWidget *widget,
+ GdkEventSelection *event)
+{
+ GtkClipboard *clipboard = gtk_clipboard_get (event->selection);
+
+ if (clipboard)
+ {
+ clipboard_unset (clipboard);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+GtkWidget *
+make_clipboard_widget (gboolean provider)
+{
+ GtkWidget *widget = gtk_invisible_new ();
+
+ gtk_signal_connect (GTK_OBJECT (widget), "selection_received",
+ GTK_SIGNAL_FUNC (selection_received), NULL);
+
+ if (provider)
+ {
+ /* We need this for gdk_x11_get_server_time() */
+ gtk_widget_add_events (widget, GDK_PROPERTY_CHANGE_MASK);
+
+ gtk_signal_connect (GTK_OBJECT (widget), "selection_get",
+ GTK_SIGNAL_FUNC (selection_get_cb), NULL);
+ gtk_signal_connect (GTK_OBJECT (widget), "selection_clear_event",
+ GTK_SIGNAL_FUNC (selection_clear_event_cb), NULL);
+ }
+
+ return widget;
+}
+
+
+void
+ensure_clipboard_widget ()
+{
+ if (!clipboard_widget)
+ clipboard_widget = make_clipboard_widget (TRUE);
+}
+
+/* This function makes a very good guess at what the correct
+ * timestamp for a selection request should be. If there is
+ * a currently processed event, it uses the timestamp for that
+ * event, otherwise it uses the current server time. However,
+ * if the time resulting from that is older than the time used
+ * last time, it uses the time used last time instead.
+ *
+ * In order implement this correctly, we never use CurrentTime,
+ * but actually retrieve the actual timestamp from the server.
+ * This is a little slower but allows us to make the guarantee
+ * that the times used by this application will always ascend
+ * and we won't get selections being rejected just because
+ * we are using a correct timestamp from an event, but used
+ * CurrentTime previously.
+ */
+static guint32
+clipboard_get_timestamp (GtkClipboard *clipboard)
+{
+ guint32 timestamp = gtk_get_current_event_time ();
+
+ ensure_clipboard_widget ();
+
+ if (timestamp == GDK_CURRENT_TIME)
+ {
+ timestamp = gdk_x11_get_server_time (clipboard_widget->window);
+ }
+ else
+ {
+ if (clipboard->timestamp != GDK_CURRENT_TIME)
+ {
+ /* Check to see if clipboard->timestamp is newer than
+ * timestamp, accounting for wraparound.
+ */
+
+ guint32 max = timestamp + 0x80000000;
+
+ if ((max > timestamp &&
+ (clipboard->timestamp > timestamp &&
+ clipboard->timestamp <= max)) ||
+ (max <= timestamp &&
+ (clipboard->timestamp > timestamp ||
+ clipboard->timestamp <= max)))
+ {
+ timestamp = clipboard->timestamp;
+ }
+ }
+ }
+
+ clipboard->timestamp = timestamp;
+
+ return timestamp;
+}
+
+static void
+clipboard_owner_destroyed (gpointer data)
+{
+ GSList *clipboards = data;
+ GSList *tmp_list;
+
+ tmp_list = clipboards;
+ while (tmp_list)
+ {
+ GtkClipboard *clipboard = tmp_list->data;
+
+ clipboard->get_func = NULL;
+ clipboard->clear_func = NULL;
+ clipboard->user_data = NULL;
+ clipboard->have_owner = FALSE;
+
+ gtk_clipboard_clear (clipboard);
+
+ tmp_list = tmp_list->next;
+ }
+
+ g_slist_free (clipboards);
+}
+
+static void
+clipboard_add_owner_notify (GtkClipboard *clipboard)
+{
+ if (!clipboards_owned_key_id)
+ clipboards_owned_key_id = g_quark_from_static_string (clipboards_owned_key);
+
+ if (clipboard->have_owner)
+ g_object_set_qdata_full (clipboard->user_data, clipboards_owned_key_id,
+ g_slist_prepend (g_object_steal_qdata (clipboard->user_data,
+ clipboards_owned_key_id),
+ clipboard),
+ clipboard_owner_destroyed);
+}
+
+static void
+clipboard_remove_owner_notify (GtkClipboard *clipboard)
+{
+ if (clipboard->have_owner)
+ g_object_set_qdata_full (clipboard->user_data, clipboards_owned_key_id,
+ g_slist_remove (g_object_steal_qdata (clipboard->user_data,
+ clipboards_owned_key_id),
+ clipboard),
+ clipboard_owner_destroyed);
+}
+
+static gboolean
+gtk_clipboard_set_contents (GtkClipboard *clipboard,
+ const GtkTargetEntry *targets,
+ guint n_targets,
+ GtkClipboardGetFunc get_func,
+ GtkClipboardClearFunc clear_func,
+ gpointer user_data,
+ gboolean have_owner)
+{
+ ensure_clipboard_widget ();
+
+ if (gtk_selection_owner_set (clipboard_widget, clipboard->selection,
+ clipboard_get_timestamp (clipboard)))
+ {
+ clipboard->have_selection = TRUE;
+
+ if (!(clipboard->have_owner && have_owner) ||
+ clipboard->user_data != user_data)
+ {
+ clipboard_unset (clipboard);
+
+ if (clipboard->get_func)
+ {
+ /* Calling unset() caused the clipboard contents to be reset!
+ * Avoid leaking and return
+ */
+ if (!(clipboard->have_owner && have_owner) ||
+ clipboard->user_data != user_data)
+ {
+ (*clear_func) (clipboard, user_data);
+ return FALSE;
+ }
+ else
+ return TRUE;
+ }
+ else
+ {
+ clipboard->user_data = user_data;
+ clipboard->have_owner = have_owner;
+ if (have_owner)
+ clipboard_add_owner_notify (clipboard);
+ }
+
+ }
+
+ clipboard->get_func = get_func;
+ clipboard->clear_func = clear_func;
+
+ gtk_selection_clear_targets (clipboard_widget, clipboard->selection);
+ gtk_selection_add_targets (clipboard_widget, clipboard->selection,
+ targets, n_targets);
+
+ return TRUE;
+ }
+ else
+ return FALSE;
+}
+
+/**
+ * gtk_clipboard_set_with_data:
+ * @clipboard: a #GtkClipboard
+ * @targets: array containing information about the available forms for the
+ * clipboard data
+ * @n_targets: number of elements in @targets
+ * @get_func: function to call to get the actual clipboard data
+ * @clear_func: when the clipboard contents are set again, this function will
+ * be called, and get_func will not be subsequently called.
+ * @user_data: user data to pass to @get_func and @clear_func.
+ *
+ * Virtually set the contents of the specified clipboard by providing
+ * a list of supported formats for the clipboard data and a function
+ * to call to get the actual data when it is requested.
+ *
+ * Return value: %TRUE if setting the clipboard data succeeded. If setting
+ * the clipboard data failed the provided callback functions
+ * will be ignored.
+ **/
+gboolean
+gtk_clipboard_set_with_data (GtkClipboard *clipboard,
+ const GtkTargetEntry *targets,
+ guint n_targets,
+ GtkClipboardGetFunc get_func,
+ GtkClipboardClearFunc clear_func,
+ gpointer user_data)
+{
+ g_return_val_if_fail (clipboard != NULL, FALSE);
+ g_return_val_if_fail (targets != NULL, FALSE);
+ g_return_val_if_fail (get_func != NULL, FALSE);
+
+ return gtk_clipboard_set_contents (clipboard, targets, n_targets,
+ get_func, clear_func, user_data,
+ FALSE);
+}
+
+/**
+ * gtk_clipboard_set_with_owner:
+ * @clipboard: a #GtkClipboard
+ * @targets: array containing information about the available forms for the
+ * clipboard data
+ * @n_targets: number of elements in @targets
+ * @get_func: function to call to get the actual clipboard data
+ * @clear_func: when the clipboard contents are set again, this function will
+ * be called, and get_func will not be subsequently called.
+ * @owner: an object that "owns" the data. This object will be passed
+ * to the callbacks when called.
+ *
+ * Virtually set the contents of the specified clipboard by providing
+ * a list of supported formats for the clipboard data and a function
+ * to call to get the actual data when it is requested.
+ *
+ * The difference between this function and gtk_clipboard_set_with_data
+ * is that instead of an generic @user_data pointer, a #GObject is passed
+ * in. Because of this,
+ *
+ * Return value: %TRUE if setting the clipboard data succeeded. If setting
+ * the clipboard data failed the provided callback functions
+ * will be ignored.
+ **/
+gboolean
+gtk_clipboard_set_with_owner (GtkClipboard *clipboard,
+ const GtkTargetEntry *targets,
+ guint n_targets,
+ GtkClipboardGetFunc get_func,
+ GtkClipboardClearFunc clear_func,
+ GObject *owner)
+{
+ g_return_val_if_fail (clipboard != NULL, FALSE);
+ g_return_val_if_fail (targets != NULL, FALSE);
+ g_return_val_if_fail (get_func != NULL, FALSE);
+ g_return_val_if_fail (G_IS_OBJECT (owner), FALSE);
+
+ return gtk_clipboard_set_contents (clipboard, targets, n_targets,
+ get_func, clear_func, owner,
+ TRUE);
+}
+
+/**
+ * gtk_clipboard_get_owner:
+ * @clipboard: a #GtkClipboard
+ *
+ * If the clipboard contents callbacks were set with gtk_clipboard_set_owner(),
+ * and the gtk_clipboard_set_with_data() or gtk_clipboard_clear() has not
+ * subsequently called, returns the @owner set by gtk_clipboard_set_owner().
+ *
+ * Return value: the owner of the clipboard, if any; otherwise %NULL.
+ **/
+GObject *
+gtk_clipboard_get_owner (GtkClipboard *clipboard)
+{
+ g_return_val_if_fail (clipboard != NULL, NULL);
+
+ if (clipboard->have_owner)
+ return clipboard->user_data;
+ else
+ return NULL;
+}
+
+static void
+clipboard_unset (GtkClipboard *clipboard)
+{
+ GtkClipboardClearFunc old_clear_func;
+ gpointer old_data;
+
+ old_clear_func = clipboard->clear_func;
+ old_data = clipboard->user_data;
+
+ if (clipboard->have_owner)
+ {
+ clipboard_remove_owner_notify (clipboard);
+ clipboard->have_owner = FALSE;
+ }
+
+ clipboard->get_func = NULL;
+ clipboard->clear_func = NULL;
+ clipboard->user_data = NULL;
+
+ if (old_clear_func)
+ old_clear_func (clipboard, old_data);
+}
+
+/**
+ * gtk_clipboard_clear:
+ * @clipboard: a #GtkClipboard
+ *
+ * Clear the contents of the clipboard. Generally this should only
+ * be called between the time you call gtk_clipboard_set_contents(),
+ * and when the @clear_func you supplied is called. Otherwise, the
+ * clipboard may be owned by someone else.
+ **/
+void
+gtk_clipboard_clear (GtkClipboard *clipboard)
+{
+ g_return_if_fail (clipboard != NULL);
+
+ if (clipboard->have_selection)
+ gtk_selection_owner_set (NULL, clipboard->selection,
+ clipboard_get_timestamp (clipboard));
+}
+
+void
+text_get_func (GtkClipboard *clipboard,
+ GtkSelectionData *selection_data,
+ guint info,
+ gpointer data)
+{
+ gtk_selection_data_set_text (selection_data, data);
+}
+
+void
+text_clear_func (GtkClipboard *clipboard,
+ gpointer data)
+{
+ g_free (data);
+}
+
+/**
+ * gtk_clipboard_set_text:
+ * @clipboard: a #GtkClipboard object
+ * @text: a UTF-8 string.
+ * @len: length of @text, in bytes, or -1, in which case
+ * the length will be determined with strlen().
+ *
+ * Set the contents of the clipboard to the given UTF-8 string. GTK+ will
+ * make a copy of the text and take responsibility for responding
+ * for requests for the text, and for converting the text into
+ * the requested format.
+ **/
+void
+gtk_clipboard_set_text (GtkClipboard *clipboard,
+ const gchar *text,
+ gint len)
+{
+ static const GtkTargetEntry targets[] = {
+ { "STRING", 0, TARGET_STRING },
+ { "TEXT", 0, TARGET_TEXT },
+ { "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT },
+ { "UTF8_STRING", 0, TARGET_UTF8_STRING }
+ };
+
+ g_return_if_fail (clipboard != NULL);
+ g_return_if_fail (text != NULL);
+
+ if (len < 0)
+ len = strlen (text);
+
+ gtk_clipboard_set_with_data (clipboard,
+ targets, G_N_ELEMENTS (targets),
+ text_get_func, text_clear_func,
+ g_strndup (text, len));
+}
+
+static void
+set_request_contents_info (GtkWidget *widget,
+ RequestContentsInfo *info)
+{
+ if (!request_contents_key_id)
+ request_contents_key_id = g_quark_from_static_string (request_contents_key);
+
+ gtk_object_set_data_by_id (GTK_OBJECT (widget),
+ request_contents_key_id,
+ info);
+}
+
+static RequestContentsInfo *
+get_request_contents_info (GtkWidget *widget)
+{
+ if (!request_contents_key_id)
+ return NULL;
+ else
+ return gtk_object_get_data_by_id (GTK_OBJECT (widget),
+ request_contents_key_id);
+}
+
+static void
+selection_received (GtkWidget *widget,
+ GtkSelectionData *selection_data,
+ guint time)
+{
+ RequestContentsInfo *request_info = get_request_contents_info (widget);
+ set_request_contents_info (widget, NULL);
+
+ request_info->callback (gtk_clipboard_get (selection_data->selection),
+ selection_data,
+ request_info->user_data);
+
+ g_free (request_info);
+
+ if (widget != clipboard_widget)
+ gtk_widget_destroy (widget);
+}
+
+/**
+ * gtk_clipboard_request_contents:
+ * @clipboard: a #GtkClipboard
+ * @target: an atom representing the form into which the clipboard
+ * owner should convert the selection.
+ * @callback: A function to call when the results are received
+ * (or the retrieval fails.) If the retrieval fails
+ * the length field of @selection_data will be
+ * negative.
+ * @user_data: user data to pass to @callback
+ *
+ * Requests the contents of clipboard as the given target.
+ * When the results of the result are later received the supplied callback
+ * will be called.
+ **/
+void
+gtk_clipboard_request_contents (GtkClipboard *clipboard,
+ GdkAtom target,
+ GtkClipboardReceivedFunc callback,
+ gpointer user_data)
+{
+ RequestContentsInfo *info;
+ GtkWidget *widget;
+
+ g_return_if_fail (clipboard != NULL);
+ g_return_if_fail (target != GDK_NONE);
+ g_return_if_fail (callback != NULL);
+
+ ensure_clipboard_widget ();
+
+ if (get_request_contents_info (clipboard_widget))
+ widget = make_clipboard_widget (FALSE);
+ else
+ widget = clipboard_widget;
+
+ info = g_new (RequestContentsInfo, 1);
+ info->callback = callback;
+ info->user_data = user_data;
+
+ set_request_contents_info (widget, info);
+
+ gtk_selection_convert (widget, clipboard->selection, target,
+ clipboard_get_timestamp (clipboard));
+}
+
+static void
+request_text_received_func (GtkClipboard *clipboard,
+ GtkSelectionData *selection_data,
+ gpointer data)
+{
+ RequestTextInfo *info = data;
+ gchar *result = NULL;
+
+ result = gtk_selection_data_get_text (selection_data);
+
+ if (!result)
+ {
+ /* If we asked for UTF8 and didn't get it, try text; if we asked
+ * for text and didn't get it, try string. If we asked for
+ * anything else and didn't get it, give up.
+ */
+ if (selection_data->target == gdk_atom_intern ("UTF8_STRING", FALSE))
+ {
+ gtk_clipboard_request_contents (clipboard,
+ gdk_atom_intern ("TEXT", FALSE),
+ request_text_received_func, info);
+ return;
+ }
+ else if (selection_data->target == gdk_atom_intern ("TEXT", FALSE))
+ {
+ gtk_clipboard_request_contents (clipboard,
+ GDK_TARGET_STRING,
+ request_text_received_func, info);
+ return;
+ }
+ }
+
+ info->callback (clipboard, result, info->user_data);
+ g_free (info);
+ g_free (result);
+}
+
+/**
+ * gtk_clipboard_request_text:
+ * @clipboard: a #GtkClipboard
+ * @callback: a function to call when the text is received,
+ * or the retrieval fails. (It will always be called
+ * one way or the other.)
+ * @user_data: user data to pass to @callback.
+ *
+ * Requests the contents of the clipboard as text. When the text is
+ * later received, it will be converted to UTF-8 if necessary, and
+ * @callback will be called.
+ *
+ * The @text parameter to @callback will contain the resulting text if
+ * the request succeeded, or %NULL if it failed. This could happen for
+ * various reasons, in particular if the clipboard was empty or if the
+ * contents of the clipboard could not be converted into text form.
+ **/
+void
+gtk_clipboard_request_text (GtkClipboard *clipboard,
+ GtkClipboardTextReceivedFunc callback,
+ gpointer user_data)
+{
+ RequestTextInfo *info;
+
+ g_return_if_fail (clipboard != NULL);
+ g_return_if_fail (callback != NULL);
+
+ info = g_new (RequestTextInfo, 1);
+ info->callback = callback;
+ info->user_data = user_data;
+
+ gtk_clipboard_request_contents (clipboard, gdk_atom_intern ("UTF8_STRING", FALSE),
+ request_text_received_func,
+ info);
+}
+
+
+typedef struct
+{
+ GMainLoop *loop;
+ gpointer data;
+} WaitResults;
+
+static void
+clipboard_received_func (GtkClipboard *clipboard,
+ GtkSelectionData *selection_data,
+ gpointer data)
+{
+ WaitResults *results = data;
+
+ if (selection_data->length >= 0)
+ results->data = gtk_selection_data_copy (selection_data);
+
+ g_main_quit (results->loop);
+}
+
+/**
+ * gtk_clipboard_wait_for_contents:
+ * @clipboard: a #GtkClipboard
+ * @target: an atom representing the form into which the clipboard
+ * owner should convert the selection.
+ *
+ * Requests the contents of the clipboard using the given target.
+ * This function waits for the data to be received using the main
+ * loop, so events, timeouts, etc, may be dispatched during the wait.
+ *
+ * Return value: a newly allocated #GtkSelectionData object or %NULL
+ * if retrieving the given target failed. If non-%NULL,
+ * this value freed with gtk_selection_data_free() when
+ * you are finished with it.
+ **/
+GtkSelectionData *
+gtk_clipboard_wait_for_contents (GtkClipboard *clipboard,
+ GdkAtom target)
+{
+ WaitResults results;
+
+ g_return_val_if_fail (clipboard != NULL, NULL);
+ g_return_val_if_fail (target != GDK_NONE, NULL);
+
+ results.data = NULL;
+ results.loop = g_main_new (TRUE);
+
+ gtk_clipboard_request_contents (clipboard, target,
+ clipboard_received_func,
+ &results);
+
+ if (g_main_is_running (results.loop))
+ g_main_run (results.loop);
+
+ g_main_destroy (results.loop);
+
+ return results.data;
+}
+
+static void
+clipboard_text_received_func (GtkClipboard *clipboard,
+ const gchar *text,
+ gpointer data)
+{
+ WaitResults *results = data;
+
+ results->data = g_strdup (text);
+ g_main_quit (results->loop);
+}
+
+
+/**
+ * gtk_clipboard_wait_for_text:
+ * @clipboard: a #GtkClipboard
+ *
+ * Requests the contents of the clipboard as text and converts
+ * the result to UTF-8 if necessary. This function waits for
+ * the data to be received using the main loop, so events,
+ * timeouts, etc, may be dispatched during the wait.
+ *
+ * Return value: a newly allocated UTF-8 string which must
+ * be freed with g_free(), or %NULL if retrieving
+ * the selection data failed. (This could happen
+ * for various reasons, in particular if the
+ * clipboard was empty or if the contents of the
+ * clipboard could not be converted into text form.)
+ **/
+gchar *
+gtk_clipboard_wait_for_text (GtkClipboard *clipboard)
+{
+ WaitResults results;
+
+ g_return_val_if_fail (clipboard != NULL, NULL);
+ g_return_val_if_fail (clipboard != NULL, NULL);
+
+ results.data = NULL;
+ results.loop = g_main_new (TRUE);
+
+ gtk_clipboard_request_text (clipboard,
+ clipboard_text_received_func,
+ &results);
+
+ if (g_main_is_running (results.loop))
+ g_main_run (results.loop);
+
+ g_main_destroy (results.loop);
+
+ return results.data;
+}
+
--- /dev/null
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2000 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Global clipboard abstraction.
+ */
+
+#ifndef __GTK_CLIPBOARD_H__
+#define __GTK_CLIPBOARD_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <gtk/gtkselection.h>
+
+typedef struct _GtkClipboard GtkClipboard;
+
+typedef void (* GtkClipboardReceivedFunc) (GtkClipboard *clipboard,
+ GtkSelectionData *selection_data,
+ gpointer data);
+typedef void (* GtkClipboardTextReceivedFunc) (GtkClipboard *clipboard,
+ const gchar *text,
+ gpointer data);
+
+/* Should these functions have GtkClipboard *clipboard as the first argument?
+ * right now for ClearFunc, you may have trouble determining _which_ clipboard
+ * was cleared, if you reuse your ClearFunc for multiple clipboards.
+ */
+typedef void (* GtkClipboardGetFunc) (GtkClipboard *clipboard,
+ GtkSelectionData *selection_data,
+ guint info,
+ gpointer user_data_or_owner);
+typedef void (* GtkClipboardClearFunc) (GtkClipboard *clipboard,
+ gpointer user_data_or_owner);
+
+GtkClipboard *gtk_clipboard_get (GdkAtom selection);
+
+gboolean gtk_clipboard_set_with_data (GtkClipboard *clipboard,
+ const GtkTargetEntry *targets,
+ guint n_targets,
+ GtkClipboardGetFunc get_func,
+ GtkClipboardClearFunc clear_func,
+ gpointer user_data);
+gboolean gtk_clipboard_set_with_owner (GtkClipboard *clipboard,
+ const GtkTargetEntry *targets,
+ guint n_targets,
+ GtkClipboardGetFunc get_func,
+ GtkClipboardClearFunc clear_func,
+ GObject *owner);
+GObject *gtk_clipboard_get_owner (GtkClipboard *clipboard);
+void gtk_clipboard_clear (GtkClipboard *clipboard);
+void gtk_clipboard_set_text (GtkClipboard *clipboard,
+ const gchar *text,
+ gint len);
+
+void gtk_clipboard_request_contents (GtkClipboard *clipboard,
+ GdkAtom target,
+ GtkClipboardReceivedFunc callback,
+ gpointer user_data);
+void gtk_clipboard_request_text (GtkClipboard *clipboard,
+ GtkClipboardTextReceivedFunc callback,
+ gpointer user_data);
+
+GtkSelectionData *gtk_clipboard_wait_for_contents (GtkClipboard *clipboard,
+ GdkAtom target);
+gchar * gtk_clipboard_wait_for_text (GtkClipboard *clipboard);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif __GTK_CLIPBOARD_H__
GTK_CURVE_TYPE_FREE /* free form curve */
} GtkCurveType;
+typedef enum {
+ GTK_DELETE_CHARS,
+ GTK_DELETE_WORD_ENDS, /* delete only the portion of the word to the
+ * left/right of cursor if we're in the middle
+ * of a word */
+ GTK_DELETE_WORDS,
+ GTK_DELETE_DISPLAY_LINES,
+ GTK_DELETE_DISPLAY_LINE_ENDS,
+ GTK_DELETE_PARAGRAPH_ENDS, /* like C-k in Emacs (or its reverse) */
+ GTK_DELETE_PARAGRAPHS, /* C-k in pico, kill whole line */
+ GTK_DELETE_WHITESPACE, /* M-\ in Emacs */
+} GtkDeleteType;
+
/* Focus movement types */
typedef enum
{
GTK_CENTIMETERS
} GtkMetricType;
+typedef enum {
+ GTK_MOVEMENT_CHARS, /* move by forw/back chars */
+ GTK_MOVEMENT_POSITIONS, /* move by left/right chars */
+ GTK_MOVEMENT_WORDS, /* move by forward/back words */
+ GTK_MOVEMENT_DISPLAY_LINES, /* move up/down lines (wrapped lines) */
+ GTK_MOVEMENT_DISPLAY_LINE_ENDS, /* move up/down lines (wrapped lines) */
+ GTK_MOVEMENT_PARAGRAPHS, /* move up/down paragraphs (newline-ended lines) */
+ GTK_MOVEMENT_PARAGRAPH_ENDS, /* move to either end of a paragraph */
+ GTK_MOVEMENT_PAGES, /* move by pages */
+ GTK_MOVEMENT_BUFFER_ENDS /* move to ends of the buffer */
+} GtkMovementStep;
+
/* Orientation for toolbars, etc. */
typedef enum
{
GtkWidget*
gtk_invisible_new (void)
{
- return GTK_WIDGET (gtk_type_new (GTK_TYPE_INVISIBLE));
+ GtkWidget *result = GTK_WIDGET (gtk_type_new (GTK_TYPE_INVISIBLE));
+ gtk_widget_realize (result);
+
+ return result;
}
static void
#include <stdlib.h>
#include <string.h>
#include <gmodule.h>
-#include "gtkbutton.h"
#include "gtkdnd.h"
#include "gtkcompat.h"
-#include "gtkhscrollbar.h"
-#include "gtkhseparator.h"
#include "gtkmain.h"
-#include "gtkpreview.h"
#include "gtkrc.h"
-#include "gtkscrolledwindow.h"
#include "gtkselection.h"
#include "gtksignal.h"
-#include "gtktable.h"
-#include "gtktext.h"
-#include "gtkvbox.h"
-#include "gtkvscrollbar.h"
#include "gtkwidget.h"
#include "gtkwindow.h"
#include "gtkprivate.h"
gtk_get_current_event (void)
{
if (current_events)
- return gdk_event_copy ((GdkEvent *) current_events->data);
+ return gdk_event_copy (current_events->data);
else
return NULL;
}
+/**
+ * gtk_get_current_event_time:
+ *
+ * If there is a current event and it has a timestamp, return that
+ * timestamp, otherwise return %GDK_CURRENT_TIME.
+ *
+ * Return value: the timestamp from the current event, or %GDK_CURRENT_TIME.
+ **/
+guint32
+gtk_get_current_event_time (void)
+{
+ if (current_events)
+ return gdk_event_get_time (current_events->data);
+ else
+ return GDK_CURRENT_TIME;
+}
+
GtkWidget*
gtk_get_event_widget (GdkEvent *event)
{
if (gtk_initialized)
{
gtk_initialized = FALSE;
- gtk_preview_uninit ();
}
}
gpointer func_data);
void gtk_key_snooper_remove (guint snooper_handler_id);
-GdkEvent* gtk_get_current_event (void);
+GdkEvent* gtk_get_current_event (void);
+guint32 gtk_get_current_event_time (void);
+
GtkWidget* gtk_get_event_widget (GdkEvent *event);
* results:
*************************************************************/
-gint
+gboolean
gtk_selection_owner_set (GtkWidget *widget,
GdkAtom selection,
guint32 time)
GtkWidget *old_owner;
GtkSelectionInfo *selection_info = NULL;
GdkWindow *window;
+
+ g_return_val_if_fail (widget == NULL || GTK_WIDGET_REALIZED (widget), FALSE);
if (widget == NULL)
window = NULL;
else
- {
- if (!GTK_WIDGET_REALIZED (widget))
- gtk_widget_realize (widget);
-
- window = widget->window;
- }
-
+ window = widget->window;
+
tmp_list = current_selections;
while (tmp_list)
{
- selection_info = (GtkSelectionInfo *)tmp_list->data;
-
- if (selection_info->selection == selection)
- break;
+ if (((GtkSelectionInfo *)tmp_list->data)->selection == selection)
+ {
+ selection_info = tmp_list->data;
+ break;
+ }
tmp_list = tmp_list->next;
}
- if (tmp_list == NULL)
- selection_info = NULL;
- else
- if (selection_info->widget == widget)
- return TRUE;
-
if (gdk_selection_owner_set (window, selection, time, TRUE))
{
old_owner = NULL;
selection_info->selection = selection;
selection_info->widget = widget;
selection_info->time = time;
- current_selections = g_list_append (current_selections,
- selection_info);
+ current_selections = g_list_prepend (current_selections,
+ selection_info);
}
else
{
}
}
/* If another widget in the application lost the selection,
- * send it a GDK_SELECTION_CLEAR event, unless we're setting
- * the owner to None, in which case an event will be sent */
- if (old_owner && (widget != NULL))
+ * send it a GDK_SELECTION_CLEAR event.
+ */
+ if (old_owner && old_owner != widget)
{
GdkEventSelection event;
gtk_object_set_data (GTK_OBJECT (widget), gtk_selection_handler_key, NULL);
}
+/**
+ * gtk_selection_clear_targets:
+ * @widget: a #GtkWidget
+ * @selection: an atom representing a selection
+ *
+ * Remove all targets registered for the given selection for the
+ * widget.
+ **/
+void
+gtk_selection_clear_targets (GtkWidget *widget,
+ GdkAtom selection)
+{
+ GtkSelectionTargetList *sellist;
+ GList *tmp_list;
+ GList *lists;
+
+ lists = gtk_object_get_data (GTK_OBJECT (widget), gtk_selection_handler_key);
+
+ tmp_list = lists;
+ while (tmp_list)
+ {
+ sellist = tmp_list->data;
+ if (sellist->selection == selection)
+ {
+ lists = g_list_delete_link (lists, tmp_list);
+ gtk_target_list_unref (sellist->list);
+ g_free (sellist);
+
+ break;
+ }
+
+ tmp_list = tmp_list->next;
+ }
+
+ gtk_object_set_data (GTK_OBJECT (widget), gtk_selection_handler_key, lists);
+}
+
void
gtk_selection_add_target (GtkWidget *widget,
GdkAtom selection,
gtk_target_list_add_table (list, targets, ntargets);
}
+
/*************************************************************
* gtk_selection_remove_all:
* Removes all handlers and unsets ownership of all
selection_data->length = length;
}
+static GdkAtom utf8_atom;
+static GdkAtom text_atom;
+static GdkAtom ctext_atom;
+
+static void
+init_atoms (void)
+{
+ if (!utf8_atom)
+ {
+ utf8_atom = gdk_atom_intern ("UTF8_STRING", FALSE);
+ text_atom = gdk_atom_intern ("TEXT", FALSE);
+ ctext_atom = gdk_atom_intern ("COMPOUND_TEXT", FALSE);
+ }
+}
+
+/**
+ * gtk_selection_data_set_text:
+ * @selection_data: a #GtkSelectionData
+ * @str: a UTF-8 string
+ *
+ * Sets the contents of the selection from a UTF-8 encoded string.
+ * The string is converted to the form determined by
+ * @selection_data->target.
+ *
+ * Return value: %TRUE if the selection was succesfully set,
+ * otherwise %FALSE.
+ **/
+gboolean
+gtk_selection_data_set_text (GtkSelectionData *selection_data,
+ const guchar *str)
+{
+ init_atoms ();
+
+ if (selection_data->target == utf8_atom)
+ {
+ gtk_selection_data_set (selection_data,
+ utf8_atom,
+ 8, (guchar *)str, strlen (str));
+ return TRUE;
+ }
+ else if (selection_data->target == GDK_TARGET_STRING)
+ {
+ gchar *latin1 = gdk_utf8_to_string_target (str);
+
+ if (latin1)
+ {
+ gtk_selection_data_set (selection_data,
+ GDK_SELECTION_TYPE_STRING,
+ 8, latin1, strlen (latin1));
+ g_free(latin1);
+
+ return TRUE;
+ }
+
+ }
+ else if (selection_data->target == ctext_atom ||
+ selection_data->target == text_atom)
+ {
+ guchar *text;
+ GdkAtom encoding;
+ gint format;
+ gint new_length;
+
+ if (gdk_utf8_to_compound_text (str, &encoding, &format, &text, &new_length))
+ {
+ gtk_selection_data_set (selection_data, encoding, format, text, new_length);
+ gdk_free_compound_text (text);
+
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+/**
+ * gtk_selection_data_get_text:
+ * @selection_data: a #GtkSelectionData
+ *
+ * Gets the contents of the selection data as a UTF-8 string.
+ *
+ * Return value: if the selection data contained a recognized
+ * text type and it could be converted to UTF-8, a newly allocated
+ * string containing the converted text, otherwise %NULL.
+ * If the result is non-%NULL it must be freed with g_free().
+ **/
+guchar *
+gtk_selection_data_get_text (GtkSelectionData *selection_data)
+{
+ guchar *result = NULL;
+
+ init_atoms ();
+
+ if (selection_data->length >= 0 &&
+ (selection_data->type == GDK_TARGET_STRING ||
+ selection_data->type == ctext_atom ||
+ selection_data->type == utf8_atom))
+ {
+ gchar **list;
+ gint i;
+ gint count = gdk_text_property_to_utf8_list (selection_data->type,
+ selection_data->format,
+ selection_data->data,
+ selection_data->length,
+ &list);
+ if (count > 0)
+ result = list[0];
+
+ for (i = 1; i < count; i++)
+ g_free (list[i]);
+ g_free (list);
+ }
+
+ return result;
+}
+
/*************************************************************
* gtk_selection_init:
* Initialize local variables
*************************************************************/
gint
-gtk_selection_clear (GtkWidget *widget,
+gtk_selection_clear (GtkWidget *widget,
GdkEventSelection *event)
{
- /* FIXME: there can be a problem if we change the selection
- via gtk_selection_owner_set after another client claims
- the selection, but before we get the notification event.
- Tk filters based on serial #'s, which aren't retained by
- GTK. Filtering based on time's will be inherently
- somewhat unreliable. */
-
+ /* Note that we filter clear events in gdkselection-x11.c, so
+ * that we only will get here if the clear event actually
+ * represents a change that we didn't do ourself.
+ */
GList *tmp_list;
GtkSelectionInfo *selection_info = NULL;
if (tmp_list)
{
- if (selection_info->time > event->time)
- return FALSE; /* return FALSE to indicate that
- * the selection was out of date,
- * and this clear should be ignored */
- else
- {
- current_selections = g_list_remove_link (current_selections, tmp_list);
- g_list_free (tmp_list);
- g_free (selection_info);
- }
+ current_selections = g_list_remove_link (current_selections, tmp_list);
+ g_list_free (tmp_list);
+ g_free (selection_info);
}
return TRUE;
GtkSelectioData*
-gtk_selection_data_copy (GtkSelectionData *data)
+gtk_selection_data_copy (GtkSelectionData *selection_data)
{
GtkSelectionData *new_data;
- g_return_val_if_fail (data != NULL, NULL);
+ g_return_val_if_fail (selection_data != NULL, NULL);
new_data = g_new (GtkSelectionData, 1);
- *new_data = *data;
+ *new_data = *selection_data;
+
+ if (selection_data->data)
+ {
+ new_data->data = g_malloc (selection_data->length + 1);
+ memcpy (new_data->data, selection_data->data, selection_data->length + 1);
+ }
return new_data;
}
{
g_return_if_fail (data != NULL);
+ if (data->data)
+ g_free (data->data);
+
g_free (data);
}
/* Public interface */
-gint gtk_selection_owner_set (GtkWidget *widget,
- GdkAtom selection,
- guint32 time);
-void gtk_selection_add_target (GtkWidget *widget,
- GdkAtom selection,
- GdkAtom target,
- guint info);
-void gtk_selection_add_targets (GtkWidget *widget,
- GdkAtom selection,
- const GtkTargetEntry *targets,
- guint ntargets);
-gint gtk_selection_convert (GtkWidget *widget,
- GdkAtom selection,
- GdkAtom target,
- guint32 time);
-
-
-void gtk_selection_data_set (GtkSelectionData *selection_data,
- GdkAtom type,
- gint format,
- const guchar *data,
- gint length);
+gboolean gtk_selection_owner_set (GtkWidget *widget,
+ GdkAtom selection,
+ guint32 time);
+void gtk_selection_add_target (GtkWidget *widget,
+ GdkAtom selection,
+ GdkAtom target,
+ guint info);
+void gtk_selection_add_targets (GtkWidget *widget,
+ GdkAtom selection,
+ const GtkTargetEntry *targets,
+ guint ntargets);
+void gtk_selection_clear_targets (GtkWidget *widget,
+ GdkAtom selection);
+gint gtk_selection_convert (GtkWidget *widget,
+ GdkAtom selection,
+ GdkAtom target,
+ guint32 time);
+void gtk_selection_data_set (GtkSelectionData *selection_data,
+ GdkAtom type,
+ gint format,
+ const guchar *data,
+ gint length);
+gboolean gtk_selection_data_set_text (GtkSelectionData *selection_data,
+ const guchar *str);
+guchar * gtk_selection_data_get_text (GtkSelectionData *selection_data);
/* Called when a widget is destroyed */
#include <string.h>
+#include "gtkclipboard.h"
#include "gtkinvisible.h"
-#include "gtkselection.h"
#include "gtksignal.h"
#include "gtktextbuffer.h"
#include "gtktextbtree.h"
#include "gtktextiterprivate.h"
#include <string.h>
+typedef struct _ClipboardRequest ClipboardRequest;
+
+struct _ClipboardRequest
+{
+ GtkTextBuffer *buffer;
+ gboolean interactive;
+ gboolean default_editable;
+ gboolean is_clipboard;
+};
+
enum {
INSERT_TEXT,
DELETE_TEXT,
static void gtk_text_buffer_update_primary_selection (GtkTextBuffer *buffer);
-static void gtk_text_buffer_update_clipboard_selection (GtkTextBuffer *buffer);
static void gtk_text_buffer_real_insert_text (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
gpointer func_data,
GtkArg *args);
-static GdkAtom clipboard_atom = GDK_NONE;
-static GdkAtom text_atom = GDK_NONE;
-static GdkAtom ctext_atom = GDK_NONE;
-static GdkAtom utf8_atom = GDK_NONE;
-
static GtkObjectClass *parent_class = NULL;
static guint signals[LAST_SIGNAL] = { 0 };
void
gtk_text_buffer_init (GtkTextBuffer *buffer)
{
- static const GtkTargetEntry targets[] = {
- { "STRING", 0, TARGET_STRING },
- { "TEXT", 0, TARGET_TEXT },
- { "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT },
- { "UTF8_STRING", 0, TARGET_UTF8_STRING }
- };
- static const gint n_targets = sizeof(targets) / sizeof(targets[0]);
-
- if (!clipboard_atom)
- clipboard_atom = gdk_atom_intern ("CLIPBOARD", FALSE);
-
- if (!text_atom)
- text_atom = gdk_atom_intern ("TEXT", FALSE);
-
- if (!ctext_atom)
- ctext_atom = gdk_atom_intern ("COMPOUND_TEXT", FALSE);
-
- if (!utf8_atom)
- utf8_atom = gdk_atom_intern ("UTF8_STRING", FALSE);
-
- buffer->selection_widget = gtk_invisible_new();
-
- gtk_selection_add_targets (buffer->selection_widget,
- GDK_SELECTION_PRIMARY,
- targets, n_targets);
- gtk_selection_add_targets (buffer->selection_widget,
- clipboard_atom,
- targets, n_targets);
}
/**
buffer = GTK_TEXT_BUFFER (object);
- gtk_widget_destroy(buffer->selection_widget);
- buffer->selection_widget = NULL;
-
if (buffer->tag_table)
{
gtk_object_unref(GTK_OBJECT(buffer->tag_table));
}
-/*
- * Clipboard
- */
-
-static void
-set_clipboard_contents_nocopy(GtkTextBuffer *buffer,
- gchar *text)
-{
- if (text && *text == '\0')
- {
- g_free(text);
- text = NULL;
- }
-
- if (buffer->clipboard_text != NULL)
- g_free(buffer->clipboard_text);
-
- buffer->clipboard_text = text;
-
- gtk_text_buffer_update_clipboard_selection(buffer);
-}
-
-void
-gtk_text_buffer_set_clipboard_contents (GtkTextBuffer *buffer,
- const gchar *text)
-{
- set_clipboard_contents_nocopy(buffer, text ? g_strdup(text) : NULL);
-}
-
-const gchar*
-gtk_text_buffer_get_clipboard_contents (GtkTextBuffer *buffer)
-{
- return buffer->clipboard_text;
-}
-
/*
* Assorted other stuff
*/
return retval;
}
-/*
- * Selection
+/* Called when we lose the primary selection.
*/
-
-static gboolean
-have_primary_x_selection(GtkWidget *widget)
-{
- return (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) ==
- widget->window);
-}
-
-static gboolean
-request_primary_x_selection(GtkWidget *widget, guint32 time)
-{
- return gtk_selection_owner_set (widget, GDK_SELECTION_PRIMARY, time);
-}
-
-static gboolean
-release_primary_x_selection(GtkWidget *widget, guint32 time)
-{
- if (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) ==
- widget->window)
- {
- gtk_selection_owner_set (NULL, GDK_SELECTION_PRIMARY, time);
- return TRUE;
- }
- else
- return FALSE;
-}
-
-
-static gboolean
-have_clipboard_x_selection(GtkWidget *widget)
-{
- return (gdk_selection_owner_get (clipboard_atom) ==
- widget->window);
-}
-
-static gboolean
-request_clipboard_x_selection(GtkWidget *widget, guint32 time)
-{
- return gtk_selection_owner_set (widget, clipboard_atom, time);
-}
-
-static gboolean
-release_clipboard_x_selection(GtkWidget *widget, guint32 time)
-{
- if (gdk_selection_owner_get (clipboard_atom) ==
- widget->window)
- {
- gtk_selection_owner_set (NULL, clipboard_atom, time);
- return TRUE;
- }
- else
- return FALSE;
-}
-
-/* Called when we lose the selection */
-static gint
-selection_clear_event(GtkWidget *widget, GdkEventSelection *event,
- gpointer data)
+static void
+clipboard_clear_cb (GtkClipboard *clipboard,
+ gpointer data)
{
- GtkTextBuffer *buffer;
+ /* Move selection_bound to the insertion point */
+ GtkTextIter insert;
+ GtkTextIter selection_bound;
+ GtkTextBuffer *buffer = GTK_TEXT_BUFFER (data);
- buffer = GTK_TEXT_BUFFER(data);
-
- /* Let the selection handling code know that the selection
- * has been changed, since we've overriden the default handler */
- if (!gtk_selection_clear (widget, event))
- return FALSE;
-
- buffer->have_selection = FALSE;
+ gtk_text_buffer_get_iter_at_mark(buffer, &insert,
+ gtk_text_buffer_get_mark (buffer, "insert"));
+ gtk_text_buffer_get_iter_at_mark(buffer, &selection_bound,
+ gtk_text_buffer_get_mark (buffer, "selection_bound"));
- if (event->selection == GDK_SELECTION_PRIMARY)
- {
- /* Move selection_bound to the insertion point */
- GtkTextIter insert;
- GtkTextIter selection_bound;
-
- gtk_text_buffer_get_iter_at_mark(buffer, &insert,
- gtk_text_buffer_get_mark (buffer, "insert"));
- gtk_text_buffer_get_iter_at_mark(buffer, &selection_bound,
- gtk_text_buffer_get_mark (buffer, "selection_bound"));
-
- if (!gtk_text_iter_equal(&insert, &selection_bound))
- gtk_text_buffer_move_mark(buffer,
- gtk_text_buffer_get_mark (buffer, "selection_bound"),
- &insert);
- }
- else if (event->selection == clipboard_atom)
- {
- gtk_text_buffer_set_clipboard_contents(buffer, NULL);
- }
-
- return TRUE;
+ if (!gtk_text_iter_equal(&insert, &selection_bound))
+ gtk_text_buffer_move_mark(buffer,
+ gtk_text_buffer_get_mark (buffer, "selection_bound"),
+ &insert);
}
-/* Called when we have the selection and someone else wants our
- data in order to paste it */
+/* Called when we have the primary selection and someone else wants our
+ * data in order to paste it.
+ */
static void
-selection_get (GtkWidget *widget,
- GtkSelectionData *selection_data,
- guint info,
- guint time,
- gpointer data)
+clipboard_get_cb (GtkClipboard *clipboard,
+ GtkSelectionData *selection_data,
+ guint info,
+ gpointer data)
{
- GtkTextBuffer *buffer;
+ GtkTextBuffer *buffer = GTK_TEXT_BUFFER(data);
gchar *str;
- guint length;
-
- buffer = GTK_TEXT_BUFFER(data);
+ GtkTextIter start, end;
- if (selection_data->selection == GDK_SELECTION_PRIMARY)
- {
- GtkTextIter start;
- GtkTextIter end;
-
- if (gtk_text_buffer_get_selection_bounds(buffer, &start, &end))
- {
- /* Extract the selected text */
- str = gtk_text_iter_get_visible_text(&start, &end);
-
- length = strlen(str);
- }
- else
- return;
- }
- else
- {
- const gchar *cstr;
-
- cstr = gtk_text_buffer_get_clipboard_contents(buffer);
-
- if (cstr == NULL)
- return;
-
- str = g_strdup(cstr);
-
- length = strlen (str);
- }
-
- if (str)
+ if (gtk_text_buffer_get_selection_bounds(buffer, &start, &end))
{
- if (info == TARGET_UTF8_STRING)
- {
- /* Pass raw UTF8 */
- gtk_selection_data_set (selection_data,
- utf8_atom,
- 8*sizeof(gchar), (guchar *)str, length);
-
- }
- else if (info == TARGET_STRING ||
- info == TARGET_TEXT)
- {
- gchar *latin1;
-
- latin1 = gtk_text_utf_to_latin1(str, length);
-
- gtk_selection_data_set (selection_data,
- GDK_SELECTION_TYPE_STRING,
- 8*sizeof(gchar), latin1, strlen(latin1));
- g_free(latin1);
- }
- else if (info == TARGET_COMPOUND_TEXT)
- {
- /* FIXME convert UTF8 directly to current locale, not via
- latin1 */
-
- guchar *text;
- GdkAtom encoding;
- gint format;
- gint new_length;
- gchar *latin1;
-
- latin1 = gtk_text_utf_to_latin1(str, length);
-
- gdk_string_to_compound_text (latin1, &encoding, &format, &text, &new_length);
- gtk_selection_data_set (selection_data, encoding, format, text, new_length);
- gdk_free_compound_text (text);
-
- g_free(latin1);
- }
-
+ /* Extract the selected text */
+ str = gtk_text_iter_get_visible_text(&start, &end);
+ gtk_selection_data_set_text (selection_data, str);
g_free (str);
}
}
-/* Called when we request a paste and receive the data */
+/* Called when we request a paste and receive the data
+ */
static void
-selection_received (GtkWidget *widget,
- GtkSelectionData *selection_data,
- guint time,
- gpointer data)
+clipboard_received (GtkClipboard *clipboard,
+ const gchar *str,
+ gpointer data)
{
- GtkTextBuffer *buffer;
- gboolean reselect;
- GtkTextIter insert_point;
- GtkTextMark *paste_point_override;
- enum {INVALID, STRING, CTEXT, UTF8} type;
-
- g_return_if_fail (widget != NULL);
-
- buffer = GTK_TEXT_BUFFER(data);
-
- if (selection_data->type == GDK_TARGET_STRING)
- type = STRING;
- else if (selection_data->type == ctext_atom)
- type = CTEXT;
- else if (selection_data->type == utf8_atom)
- type = UTF8;
- else
- type = INVALID;
-
- if (type == INVALID || selection_data->length < 0)
- {
- /* If we asked for UTF8 and didn't get it, try text; if we asked
- for text and didn't get it, try string. If we asked for
- anything else and didn't get it, give up. */
- if (selection_data->target == utf8_atom)
- gtk_selection_convert (widget, selection_data->selection,
- GDK_TARGET_STRING, time);
- return;
- }
-
- paste_point_override = gtk_text_buffer_get_mark (buffer,
- "__paste_point_override");
-
- if (paste_point_override != NULL)
- {
- gtk_text_buffer_get_iter_at_mark(buffer, &insert_point,
- paste_point_override);
- gtk_text_buffer_delete_mark(buffer,
- gtk_text_buffer_get_mark (buffer,
- "__paste_point_override"));
- }
- else
- {
- gtk_text_buffer_get_iter_at_mark(buffer, &insert_point,
- gtk_text_buffer_get_mark (buffer,
- "insert"));
- }
-
- reselect = FALSE;
+ ClipboardRequest *request_data = data;
+ GtkTextBuffer *buffer = request_data->buffer;
- if ((TRUE/* Text is selected FIXME */) &&
- (!buffer->have_selection ||
- (selection_data->selection == clipboard_atom)))
+ if (str)
{
- reselect = TRUE;
-
- if (buffer->have_selection)
- {
- /* FIXME Delete currently-selected chars but don't give up X
- selection since we'll use the newly-pasted stuff as
- a new X selection */
+ gboolean reselect;
+ GtkTextIter insert_point;
+ GtkTextMark *paste_point_override;
- }
+ paste_point_override = gtk_text_buffer_get_mark (buffer,
+ "__paste_point_override");
+
+ if (paste_point_override != NULL)
+ {
+ gtk_text_buffer_get_iter_at_mark(buffer, &insert_point,
+ paste_point_override);
+ gtk_text_buffer_delete_mark(buffer,
+ gtk_text_buffer_get_mark (buffer,
+ "__paste_point_override"));
+ }
else
- ; /* FIXME Delete selected chars and give up X selection */
- }
-
- switch (type)
- {
- case STRING:
- {
- gchar *utf;
-
- utf = gtk_text_latin1_to_utf((const gchar*)selection_data->data,
- selection_data->length);
- if (buffer->paste_interactive)
- gtk_text_buffer_insert_interactive (buffer, &insert_point,
- utf, -1, buffer->paste_default_editable);
- else
- gtk_text_buffer_insert (buffer, &insert_point,
- utf, -1);
- g_free(utf);
- }
- break;
+ {
+ gtk_text_buffer_get_iter_at_mark(buffer, &insert_point,
+ gtk_text_buffer_get_mark (buffer,
+ "insert"));
+ }
- case UTF8:
- gtk_text_buffer_insert (buffer, &insert_point,
- (const gchar *)selection_data->data,
- selection_data->length);
- break;
+ reselect = FALSE;
+
+ /* FIXME ALL OF THIS - I think that the "best method" is that when pasting
+ * with the cursor inside the selection area, you replace the selection
+ * with the new text, otherwise, you simply insert the new text at
+ * the point where the click occured, unselecting any selected text.
+ *
+ * This probably is best implemented as a "replace_selection" flag in
+ * ClipboardRequest.
+ */
+#if 0
+ if ((TRUE/* Text is selected FIXME */) &&
+ (!buffer->have_selection || request_data->is_clipboard))
+ {
+ reselect = TRUE;
+
+ if (buffer->have_selection)
+ {
+ /* FIXME Delete currently-selected chars but don't give up X
+ selection since we'll use the newly-pasted stuff as
+ a new X selection */
+
+ }
+ else
+ ; /* FIXME Delete selected chars and give up X selection */
+ }
+#endif
- case CTEXT:
- {
- gchar **list;
- gint count;
- gint i;
-
- count = gdk_text_property_to_text_list (selection_data->type,
- selection_data->format,
- selection_data->data,
- selection_data->length,
- &list);
- for (i=0; i<count; i++)
- {
- /* list contains stuff in our default encoding */
- gboolean free_utf = FALSE;
- gchar *utf = NULL;
- gchar *charset = NULL;
-
- if (g_get_charset (&charset))
- {
- utf = g_convert (list[i], -1,
- "UTF8", charset,
- NULL);
- free_utf = TRUE;
- }
- else
- utf = list[i];
-
- if (buffer->paste_interactive)
- gtk_text_buffer_insert_interactive (buffer, &insert_point,
- utf, -1, buffer->paste_default_editable);
- else
- gtk_text_buffer_insert (buffer, &insert_point,
- utf, -1);
-
- if (free_utf)
- g_free(utf);
- }
-
- if (count > 0)
- gdk_free_text_list (list);
- }
- break;
- case INVALID: /* quiet compiler */
- break;
+ if (request_data->interactive)
+ gtk_text_buffer_insert_interactive (buffer, &insert_point,
+ str, -1, request_data->default_editable);
+ else
+ gtk_text_buffer_insert (buffer, &insert_point,
+ str, -1);
+
+ if (reselect)
+ ; /* FIXME Select the region of text we just inserted */
}
- if (reselect)
- ; /* FIXME Select the region of text we just inserted */
-
+ g_object_unref (G_OBJECT (buffer));
+ g_free (request_data);
}
static void
-ensure_handlers(GtkTextBuffer *buffer)
+gtk_text_buffer_update_primary_selection (GtkTextBuffer *buffer)
{
- if (!buffer->selection_handlers_installed)
- {
- buffer->selection_handlers_installed = TRUE;
-
- gtk_signal_connect(GTK_OBJECT(buffer->selection_widget),
- "selection_clear_event",
- GTK_SIGNAL_FUNC(selection_clear_event),
- buffer);
-
- gtk_signal_connect(GTK_OBJECT(buffer->selection_widget),
- "selection_received",
- GTK_SIGNAL_FUNC(selection_received),
- buffer);
-
- gtk_signal_connect(GTK_OBJECT(buffer->selection_widget),
- "selection_get",
- GTK_SIGNAL_FUNC(selection_get),
- buffer);
- }
-}
+ static const GtkTargetEntry targets[] = {
+ { "STRING", 0, TARGET_STRING },
+ { "TEXT", 0, TARGET_TEXT },
+ { "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT },
+ { "UTF8_STRING", 0, TARGET_UTF8_STRING }
+ };
-/* FIXME GDK_CURRENT_TIME should probably go away and we should
- figure out how to get the events in here */
-static void
-gtk_text_buffer_update_primary_selection(GtkTextBuffer *buffer)
-{
GtkTextIter start;
GtkTextIter end;
- ensure_handlers(buffer);
-
+ GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
+
/* Determine whether we have a selection and adjust X selection
- accordingly. */
+ * accordingly.
+ */
- if (!gtk_text_buffer_get_selection_bounds(buffer, &start, &end))
- {
- release_primary_x_selection(buffer->selection_widget, GDK_CURRENT_TIME);
- buffer->have_selection = FALSE;
- }
- else
- {
- /* Even if we already have the selection, we need to update our
- timestamp. */
- buffer->have_selection = FALSE;
- request_primary_x_selection(buffer->selection_widget, GDK_CURRENT_TIME);
- if (have_primary_x_selection(buffer->selection_widget))
- buffer->have_selection = TRUE;
- }
-}
-
-static void
-gtk_text_buffer_update_clipboard_selection(GtkTextBuffer *buffer)
-{
- if (buffer->clipboard_text == NULL ||
- buffer->clipboard_text[0] == '\0')
+ if (!gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
{
- release_clipboard_x_selection(buffer->selection_widget, GDK_CURRENT_TIME);
+ if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (buffer))
+ gtk_clipboard_clear (clipboard);
}
else
{
/* Even if we already have the selection, we need to update our
- timestamp. */
- request_clipboard_x_selection(buffer->selection_widget, GDK_CURRENT_TIME);
+ * timestamp.
+ */
+ if (!gtk_clipboard_set_with_owner (clipboard, targets, G_N_ELEMENTS (targets),
+ clipboard_get_cb, clipboard_clear_cb, G_OBJECT (buffer)))
+ clipboard_clear_cb (clipboard, buffer);
}
}
static void
-paste (GtkTextBuffer *buffer, GdkAtom selection, guint32 time,
+paste (GtkTextBuffer *buffer,
+ gboolean is_clipboard,
gboolean interactive,
gboolean default_editable)
{
- ensure_handlers(buffer);
+ ClipboardRequest *data = g_new (ClipboardRequest, 1);
- buffer->paste_interactive = interactive;
- buffer->paste_default_editable = default_editable;
-
- gtk_selection_convert (buffer->selection_widget, selection,
- utf8_atom, time);
+ data->buffer = buffer;
+ g_object_ref (G_OBJECT (buffer));
+ data->interactive = interactive;
+ data->default_editable = default_editable;
+
+ gtk_clipboard_request_text (gtk_clipboard_get (is_clipboard ? GDK_NONE : GDK_SELECTION_PRIMARY),
+ clipboard_received, data);
}
void
-gtk_text_buffer_paste_primary_selection(GtkTextBuffer *buffer,
- GtkTextIter *override_location,
- guint32 time,
- gboolean interactive,
- gboolean default_editable)
+gtk_text_buffer_paste_primary (GtkTextBuffer *buffer,
+ GtkTextIter *override_location,
+ gboolean default_editable)
{
if (override_location != NULL)
gtk_text_buffer_create_mark(buffer,
"__paste_point_override",
override_location, FALSE);
- paste(buffer, GDK_SELECTION_PRIMARY, time, interactive, default_editable);
+ paste (buffer, FALSE, TRUE, default_editable);
}
void
-gtk_text_buffer_paste_clipboard (GtkTextBuffer *buffer,
- guint32 time,
- gboolean interactive,
- gboolean default_editable)
+gtk_text_buffer_paste_clipboard (GtkTextBuffer *buffer,
+ gboolean default_editable)
{
- paste(buffer, clipboard_atom, time, interactive, default_editable);
+ paste (buffer, TRUE, TRUE, default_editable);
}
gboolean
gtk_text_buffer_delete_interactive (buffer, &start, &end, default_editable);
else
gtk_text_buffer_delete (buffer, &start, &end);
-
- gtk_text_buffer_update_primary_selection(buffer);
+
return TRUE; /* We deleted stuff */
}
}
static void
cut_or_copy(GtkTextBuffer *buffer,
- guint32 time,
gboolean delete_region_after,
gboolean interactive,
gboolean default_editable)
if (!gtk_text_iter_equal(&start, &end))
{
+ GtkClipboard *clipboard = gtk_clipboard_get (GDK_NONE);
gchar *text;
- text = gtk_text_iter_get_visible_text(&start, &end);
-
- set_clipboard_contents_nocopy(buffer, text);
+ text = gtk_text_iter_get_visible_text (&start, &end);
+ gtk_clipboard_set_text (clipboard, text, -1);
+ g_free (text);
if (delete_region_after)
{
}
void
-gtk_text_buffer_cut (GtkTextBuffer *buffer,
- guint32 time,
- gboolean interactive,
- gboolean default_editable)
+gtk_text_buffer_cut_clipboard (GtkTextBuffer *buffer,
+ gboolean default_editable)
{
- cut_or_copy(buffer, time, TRUE, interactive, default_editable);
+ cut_or_copy (buffer, TRUE, TRUE, default_editable);
}
void
-gtk_text_buffer_copy (GtkTextBuffer *buffer,
- guint32 time)
+gtk_text_buffer_copy_clipboard (GtkTextBuffer *buffer)
{
- cut_or_copy(buffer, time, FALSE, FALSE, TRUE);
+ cut_or_copy (buffer, FALSE, TRUE, TRUE);
}
GtkTextTagTable *tag_table;
GtkTextBTree *btree;
- /* Text currently pasted to the clipboard */
- gchar *clipboard_text;
-
/* Whether the buffer has been modified since last save */
gboolean modified;
-
- /* We use this for selections */
- GtkWidget *selection_widget;
- gboolean have_selection;
- gboolean selection_handlers_installed;
- gboolean paste_interactive;
- gboolean paste_default_editable;
};
struct _GtkTextBufferClass {
gboolean gtk_text_buffer_modified (GtkTextBuffer *buffer);
void gtk_text_buffer_set_modified (GtkTextBuffer *buffer,
gboolean setting);
-void gtk_text_buffer_set_clipboard_contents (GtkTextBuffer *buffer,
- const gchar *text);
-const gchar *gtk_text_buffer_get_clipboard_contents (GtkTextBuffer *buffer);
-
-void gtk_text_buffer_paste_primary_selection (GtkTextBuffer *buffer,
+void gtk_text_buffer_paste_primary (GtkTextBuffer *buffer,
GtkTextIter *override_location,
- guint32 time,
- gboolean interactive,
- gboolean default_editable);
-gboolean gtk_text_buffer_delete_selection (GtkTextBuffer *buffer,
- gboolean interactive,
gboolean default_editable);
-void gtk_text_buffer_cut (GtkTextBuffer *buffer,
- guint32 time,
- gboolean interactive,
+void gtk_text_buffer_cut_clipboard (GtkTextBuffer *buffer,
gboolean default_editable);
-void gtk_text_buffer_copy (GtkTextBuffer *buffer,
- guint32 time);
+void gtk_text_buffer_copy_clipboard (GtkTextBuffer *buffer);
void gtk_text_buffer_paste_clipboard (GtkTextBuffer *buffer,
- guint32 time,
- gboolean interactive,
gboolean default_editable);
+
gboolean gtk_text_buffer_get_selection_bounds (GtkTextBuffer *buffer,
GtkTextIter *start,
GtkTextIter *end);
-
+gboolean gtk_text_buffer_delete_selection (GtkTextBuffer *buffer,
+ gboolean interactive,
+ gboolean default_editable);
/* This function is not implemented. */
gboolean gtk_text_buffer_find_string(GtkTextBuffer *buffer,
}
}
+/**
+ * gtk_text_layout_move_iter_to_line_end:
+ * @layout: a #GtkTextLayout
+ * @direction: if negative, move to beginning of line, otherwise
+ move to end of line.
+ *
+ * Move to the beginning or end of a display line.
+ **/
+void
+gtk_text_layout_move_iter_to_line_end (GtkTextLayout *layout,
+ GtkTextIter *iter,
+ gint direction)
+{
+ GtkTextLine *line;
+ GtkTextLineDisplay *display;
+ gint line_byte;
+ gint byte_offset = 0;
+ GSList *tmp_list;
+
+ g_return_if_fail (layout != NULL);
+ g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));
+ g_return_if_fail (iter != NULL);
+
+ line = gtk_text_iter_get_text_line (iter);
+ line_byte = gtk_text_iter_get_line_index (iter);
+
+ display = gtk_text_layout_get_line_display (layout, line, FALSE);
+
+ tmp_list = pango_layout_get_lines (display->layout);
+ while (tmp_list)
+ {
+ PangoLayoutLine *layout_line = tmp_list->data;
+
+ if (line_byte < byte_offset + layout_line->length || !tmp_list->next)
+ {
+ gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
+ iter, line,
+ direction < 0 ? byte_offset : layout_line->length);
+
+ /* FIXME: Move back one position to avoid going to next line
+ */
+ if (direction < 0 && layout_line->length > 0)
+ gtk_text_iter_prev_char (iter);
+
+ break;
+ }
+
+ byte_offset += layout_line->length;
+ tmp_list = tmp_list->next;
+ }
+
+ gtk_text_layout_free_line_display (layout, display);
+}
+
/**
* gtk_text_layout_move_iter_to_x:
* @layout: a #GtkTextLayout
gint top,
gint bottom);
+void gtk_text_layout_move_iter_to_line_end (GtkTextLayout *layout,
+ GtkTextIter *iter,
+ gint direction);
void gtk_text_layout_move_iter_to_previous_line (GtkTextLayout *layout,
GtkTextIter *iter);
void gtk_text_layout_move_iter_to_next_line (GtkTextLayout *layout,
GtkTextIter *iter,
gint count);
-
void gtk_text_layout_spew (GtkTextLayout *layout);
#ifdef __cplusplus
#include <string.h>
enum {
- MOVE_INSERT,
+ MOVE,
SET_ANCHOR,
- SCROLL_TEXT,
- DELETE_TEXT,
- CUT_TEXT,
- COPY_TEXT,
- PASTE_TEXT,
+ INSERT,
+ DELETE,
+ CUT_CLIPBOARD,
+ COPY_CLIPBOARD,
+ PASTE_CLIPBOARD,
TOGGLE_OVERWRITE,
SET_SCROLL_ADJUSTMENTS,
LAST_SIGNAL
GtkAdjustment *hadj,
GtkAdjustment *vadj);
-static void gtk_text_view_move_insert (GtkTextView *text_view,
- GtkTextViewMovementStep step,
- gint count,
- gboolean extend_selection);
-static void gtk_text_view_set_anchor (GtkTextView *text_view);
-static void gtk_text_view_scroll_text (GtkTextView *text_view,
- GtkTextViewScrollType type);
-static void gtk_text_view_delete_text (GtkTextView *text_view,
- GtkTextViewDeleteType type,
- gint count);
-static void gtk_text_view_cut_text (GtkTextView *text_view);
-static void gtk_text_view_copy_text (GtkTextView *text_view);
-static void gtk_text_view_paste_text (GtkTextView *text_view);
-static void gtk_text_view_toggle_overwrite (GtkTextView *text_view);
-
+static void gtk_text_view_move (GtkTextView *text_view,
+ GtkMovementStep step,
+ gint count,
+ gboolean extend_selection);
+static void gtk_text_view_set_anchor (GtkTextView *text_view);
+static void gtk_text_view_scroll_pages (GtkTextView *text_view,
+ gint count);
+static void gtk_text_view_insert (GtkTextView *text_view,
+ const gchar *str);
+static void gtk_text_view_delete (GtkTextView *text_view,
+ GtkDeleteType type,
+ gint count);
+static void gtk_text_view_cut_clipboard (GtkTextView *text_view);
+static void gtk_text_view_copy_clipboard (GtkTextView *text_view);
+static void gtk_text_view_paste_clipboard (GtkTextView *text_view);
+static void gtk_text_view_toggle_overwrite (GtkTextView *text_view);
static void gtk_text_view_validate_onscreen (GtkTextView *text_view);
static void gtk_text_view_get_first_para_iter (GtkTextView *text_view,
TARGET_UTF8_STRING
};
-static GdkAtom clipboard_atom = GDK_NONE;
-static GdkAtom text_atom = GDK_NONE;
-static GdkAtom ctext_atom = GDK_NONE;
-static GdkAtom utf8_atom = GDK_NONE;
-
-
static GtkTargetEntry target_table[] = {
{ "UTF8_STRING", 0, TARGET_UTF8_STRING },
{ "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT },
{ "STRING", 0, TARGET_STRING }
};
-static guint n_targets = sizeof (target_table) / sizeof (target_table[0]);
-
static GtkContainerClass *parent_class = NULL;
static guint signals[LAST_SIGNAL] = { 0 };
}
static void
-add_move_insert_binding (GtkBindingSet *binding_set,
- guint keyval,
- guint modmask,
- GtkTextViewMovementStep step,
- gint count)
+add_move_binding (GtkBindingSet *binding_set,
+ guint keyval,
+ guint modmask,
+ GtkMovementStep step,
+ gint count)
{
g_return_if_fail ((modmask & GDK_SHIFT_MASK) == 0);
gtk_binding_entry_add_signal (binding_set, keyval, modmask,
- "move_insert", 3,
+ "move", 3,
GTK_TYPE_ENUM, step,
GTK_TYPE_INT, count,
GTK_TYPE_BOOL, FALSE);
/* Selection-extending version */
gtk_binding_entry_add_signal (binding_set, keyval, modmask | GDK_SHIFT_MASK,
- "move_insert", 3,
+ "move", 3,
GTK_TYPE_ENUM, step,
GTK_TYPE_INT, count,
GTK_TYPE_BOOL, TRUE);
* Signals
*/
- signals[MOVE_INSERT] =
- gtk_signal_new ("move_insert",
+ signals[MOVE] =
+ gtk_signal_new ("move",
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
- GTK_SIGNAL_OFFSET (GtkTextViewClass, move_insert),
+ GTK_SIGNAL_OFFSET (GtkTextViewClass, move),
gtk_marshal_NONE__INT_INT_INT,
- GTK_TYPE_NONE, 3, GTK_TYPE_ENUM, GTK_TYPE_INT, GTK_TYPE_BOOL);
+ GTK_TYPE_NONE, 3, GTK_TYPE_MOVEMENT_STEP, GTK_TYPE_INT, GTK_TYPE_BOOL);
signals[SET_ANCHOR] =
gtk_signal_new ("set_anchor",
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
- signals[SCROLL_TEXT] =
- gtk_signal_new ("scroll_text",
+ signals[INSERT] =
+ gtk_signal_new ("insert",
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
- GTK_SIGNAL_OFFSET (GtkTextViewClass, scroll_text),
- gtk_marshal_NONE__INT,
- GTK_TYPE_NONE, 1, GTK_TYPE_ENUM);
+ GTK_SIGNAL_OFFSET (GtkTextViewClass, insert),
+ gtk_marshal_NONE__STRING,
+ GTK_TYPE_NONE, 1, GTK_TYPE_STRING);
- signals[DELETE_TEXT] =
- gtk_signal_new ("delete_text",
+ signals[DELETE] =
+ gtk_signal_new ("delete",
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
- GTK_SIGNAL_OFFSET (GtkTextViewClass, delete_text),
+ GTK_SIGNAL_OFFSET (GtkTextViewClass, delete),
gtk_marshal_NONE__INT_INT,
- GTK_TYPE_NONE, 2, GTK_TYPE_ENUM, GTK_TYPE_INT);
+ GTK_TYPE_NONE, 2, GTK_TYPE_DELETE_TYPE, GTK_TYPE_INT);
- signals[CUT_TEXT] =
- gtk_signal_new ("cut_text",
+ signals[CUT_CLIPBOARD] =
+ gtk_signal_new ("cut_clipboard",
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
- GTK_SIGNAL_OFFSET (GtkTextViewClass, cut_text),
+ GTK_SIGNAL_OFFSET (GtkTextViewClass, cut_clipboard),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
- signals[COPY_TEXT] =
- gtk_signal_new ("copy_text",
+ signals[COPY_CLIPBOARD] =
+ gtk_signal_new ("copy_clipboard",
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
- GTK_SIGNAL_OFFSET (GtkTextViewClass, copy_text),
+ GTK_SIGNAL_OFFSET (GtkTextViewClass, copy_clipboard),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
- signals[PASTE_TEXT] =
- gtk_signal_new ("paste_text",
+ signals[PASTE_CLIPBOARD] =
+ gtk_signal_new ("paste_clipboard",
GTK_RUN_LAST | GTK_RUN_ACTION,
GTK_CLASS_TYPE (object_class),
- GTK_SIGNAL_OFFSET (GtkTextViewClass, paste_text),
+ GTK_SIGNAL_OFFSET (GtkTextViewClass, paste_clipboard),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
binding_set = gtk_binding_set_by_class (klass);
/* Moving the insertion point */
- add_move_insert_binding (binding_set, GDK_Right, 0,
- GTK_TEXT_MOVEMENT_POSITIONS, 1);
+ add_move_binding (binding_set, GDK_Right, 0,
+ GTK_MOVEMENT_POSITIONS, 1);
- add_move_insert_binding (binding_set, GDK_Left, 0,
- GTK_TEXT_MOVEMENT_POSITIONS, -1);
+ add_move_binding (binding_set, GDK_Left, 0,
+ GTK_MOVEMENT_POSITIONS, -1);
- add_move_insert_binding (binding_set, GDK_f, GDK_CONTROL_MASK,
- GTK_TEXT_MOVEMENT_CHAR, 1);
+ add_move_binding (binding_set, GDK_f, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_CHARS, 1);
- add_move_insert_binding (binding_set, GDK_b, GDK_CONTROL_MASK,
- GTK_TEXT_MOVEMENT_CHAR, -1);
+ add_move_binding (binding_set, GDK_b, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_CHARS, -1);
- add_move_insert_binding (binding_set, GDK_Right, GDK_CONTROL_MASK,
- GTK_TEXT_MOVEMENT_WORD, 1);
+ add_move_binding (binding_set, GDK_Right, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_WORDS, 1);
- add_move_insert_binding (binding_set, GDK_Left, GDK_CONTROL_MASK,
- GTK_TEXT_MOVEMENT_WORD, -1);
+ add_move_binding (binding_set, GDK_Left, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_WORDS, -1);
/* Eventually we want to move by display lines, not paragraphs */
- add_move_insert_binding (binding_set, GDK_Up, 0,
- GTK_TEXT_MOVEMENT_WRAPPED_LINE, -1);
+ add_move_binding (binding_set, GDK_Up, 0,
+ GTK_MOVEMENT_DISPLAY_LINES, -1);
- add_move_insert_binding (binding_set, GDK_Down, 0,
- GTK_TEXT_MOVEMENT_WRAPPED_LINE, 1);
+ add_move_binding (binding_set, GDK_Down, 0,
+ GTK_MOVEMENT_DISPLAY_LINES, 1);
- add_move_insert_binding (binding_set, GDK_p, GDK_CONTROL_MASK,
- GTK_TEXT_MOVEMENT_WRAPPED_LINE, -1);
+ add_move_binding (binding_set, GDK_p, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_DISPLAY_LINES, -1);
- add_move_insert_binding (binding_set, GDK_n, GDK_CONTROL_MASK,
- GTK_TEXT_MOVEMENT_WRAPPED_LINE, 1);
+ add_move_binding (binding_set, GDK_n, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_DISPLAY_LINES, 1);
- add_move_insert_binding (binding_set, GDK_a, GDK_CONTROL_MASK,
- GTK_TEXT_MOVEMENT_LINE_ENDS, -1);
+ add_move_binding (binding_set, GDK_a, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_PARAGRAPH_ENDS, -1);
- add_move_insert_binding (binding_set, GDK_e, GDK_CONTROL_MASK,
- GTK_TEXT_MOVEMENT_LINE_ENDS, 1);
+ add_move_binding (binding_set, GDK_e, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_PARAGRAPH_ENDS, 1);
- add_move_insert_binding (binding_set, GDK_f, GDK_MOD1_MASK,
- GTK_TEXT_MOVEMENT_WORD, 1);
+ add_move_binding (binding_set, GDK_f, GDK_MOD1_MASK,
+ GTK_MOVEMENT_WORDS, 1);
- add_move_insert_binding (binding_set, GDK_b, GDK_MOD1_MASK,
- GTK_TEXT_MOVEMENT_WORD, -1);
+ add_move_binding (binding_set, GDK_b, GDK_MOD1_MASK,
+ GTK_MOVEMENT_WORDS, -1);
- add_move_insert_binding (binding_set, GDK_Home, 0,
- GTK_TEXT_MOVEMENT_BUFFER_ENDS, -1);
+ add_move_binding (binding_set, GDK_Home, 0,
+ GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
- add_move_insert_binding (binding_set, GDK_End, 0,
- GTK_TEXT_MOVEMENT_BUFFER_ENDS, 1);
+ add_move_binding (binding_set, GDK_End, 0,
+ GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
+
+ add_move_binding (binding_set, GDK_Home, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_BUFFER_ENDS, -1);
+
+ add_move_binding (binding_set, GDK_End, GDK_CONTROL_MASK,
+ GTK_MOVEMENT_BUFFER_ENDS, 1);
+
+ add_move_binding (binding_set, GDK_Page_Up, 0,
+ GTK_MOVEMENT_PAGES, -1);
+
+ add_move_binding (binding_set, GDK_Page_Down, 0,
+ GTK_MOVEMENT_PAGES, 1);
+
/* Setting the cut/paste/copy anchor */
gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_CONTROL_MASK,
"set_anchor", 0);
-
- /* Scrolling around */
- gtk_binding_entry_add_signal (binding_set, GDK_Page_Up, 0,
- "scroll_text", 1,
- GTK_TYPE_ENUM, GTK_TEXT_SCROLL_PAGE_UP);
-
- gtk_binding_entry_add_signal (binding_set, GDK_Page_Down, 0,
- "scroll_text", 1,
- GTK_TYPE_ENUM, GTK_TEXT_SCROLL_PAGE_DOWN);
-
/* Deleting text */
gtk_binding_entry_add_signal (binding_set, GDK_Delete, 0,
- "delete_text", 2,
- GTK_TYPE_ENUM, GTK_TEXT_DELETE_CHAR,
+ "delete", 2,
+ GTK_TYPE_ENUM, GTK_DELETE_CHARS,
+ GTK_TYPE_INT, 1);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_d, GDK_CONTROL_MASK,
+ "delete", 2,
+ GTK_TYPE_ENUM, GTK_DELETE_CHARS,
GTK_TYPE_INT, 1);
gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, 0,
- "delete_text", 2,
- GTK_TYPE_ENUM, GTK_TEXT_DELETE_CHAR,
+ "delete", 2,
+ GTK_TYPE_ENUM, GTK_DELETE_CHARS,
GTK_TYPE_INT, -1);
gtk_binding_entry_add_signal (binding_set, GDK_Delete, GDK_CONTROL_MASK,
- "delete_text", 2,
- GTK_TYPE_ENUM, GTK_TEXT_DELETE_HALF_WORD,
+ "delete", 2,
+ GTK_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
+ GTK_TYPE_INT, 1);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_d, GDK_MOD1_MASK,
+ "delete", 2,
+ GTK_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
GTK_TYPE_INT, 1);
gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, GDK_CONTROL_MASK,
- "delete_text", 2,
- GTK_TYPE_ENUM, GTK_TEXT_DELETE_HALF_WORD,
+ "delete", 2,
+ GTK_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
GTK_TYPE_INT, -1);
gtk_binding_entry_add_signal (binding_set, GDK_k, GDK_CONTROL_MASK,
- "delete_text", 2,
- GTK_TYPE_ENUM, GTK_TEXT_DELETE_HALF_LINE,
+ "delete", 2,
+ GTK_TYPE_ENUM, GTK_DELETE_PARAGRAPH_ENDS,
GTK_TYPE_INT, 1);
gtk_binding_entry_add_signal (binding_set, GDK_u, GDK_CONTROL_MASK,
- "delete_text", 2,
- GTK_TYPE_ENUM, GTK_TEXT_DELETE_WHOLE_LINE,
+ "delete", 2,
+ GTK_TYPE_ENUM, GTK_DELETE_PARAGRAPHS,
GTK_TYPE_INT, 1);
gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_MOD1_MASK,
- "delete_text", 2,
- GTK_TYPE_ENUM, GTK_TEXT_DELETE_WHITESPACE_LEAVE_ONE,
+ "delete", 2,
+ GTK_TYPE_ENUM, GTK_DELETE_WHITESPACE,
GTK_TYPE_INT, 1);
+ gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_MOD1_MASK,
+ "insert", 1,
+ GTK_TYPE_STRING, " ");
gtk_binding_entry_add_signal (binding_set, GDK_backslash, GDK_MOD1_MASK,
- "delete_text", 2,
- GTK_TYPE_ENUM, GTK_TEXT_DELETE_WHITESPACE,
+ "delete", 2,
+ GTK_TYPE_ENUM, GTK_DELETE_WHITESPACE,
GTK_TYPE_INT, 1);
/* Cut/copy/paste */
gtk_binding_entry_add_signal (binding_set, GDK_x, GDK_CONTROL_MASK,
- "cut_text", 0);
+ "cut_clipboard", 0);
gtk_binding_entry_add_signal (binding_set, GDK_w, GDK_CONTROL_MASK,
- "cut_text", 0);
+ "cut_clipboard", 0);
gtk_binding_entry_add_signal (binding_set, GDK_c, GDK_CONTROL_MASK,
- "copy_text", 0);
+ "copy_clipboard", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_v, GDK_CONTROL_MASK,
+ "paste_clipboard", 0);
+
gtk_binding_entry_add_signal (binding_set, GDK_y, GDK_CONTROL_MASK,
- "paste_text", 0);
+ "paste_clipboard", 0);
/* Overwrite */
gtk_binding_entry_add_signal (binding_set, GDK_Insert, 0,
widget_class->drag_drop = gtk_text_view_drag_drop;
widget_class->drag_data_received = gtk_text_view_drag_data_received;
- klass->move_insert = gtk_text_view_move_insert;
+ klass->move = gtk_text_view_move;
klass->set_anchor = gtk_text_view_set_anchor;
- klass->scroll_text = gtk_text_view_scroll_text;
- klass->delete_text = gtk_text_view_delete_text;
- klass->cut_text = gtk_text_view_cut_text;
- klass->copy_text = gtk_text_view_copy_text;
- klass->paste_text = gtk_text_view_paste_text;
+ klass->insert = gtk_text_view_insert;
+ klass->delete = gtk_text_view_delete;
+ klass->cut_clipboard = gtk_text_view_cut_clipboard;
+ klass->copy_clipboard = gtk_text_view_copy_clipboard;
+ klass->paste_clipboard = gtk_text_view_paste_clipboard;
klass->toggle_overwrite = gtk_text_view_toggle_overwrite;
klass->set_scroll_adjustments = gtk_text_view_set_scroll_adjustments;
}
text_view->wrap_mode = GTK_WRAPMODE_NONE;
- if (!clipboard_atom)
- clipboard_atom = gdk_atom_intern ("CLIPBOARD", FALSE);
-
- if (!text_atom)
- text_atom = gdk_atom_intern ("TEXT", FALSE);
-
- if (!ctext_atom)
- ctext_atom = gdk_atom_intern ("COMPOUND_TEXT", FALSE);
-
- if (!utf8_atom)
- utf8_atom = gdk_atom_intern ("UTF8_STRING", FALSE);
-
gtk_drag_dest_set (widget,
GTK_DEST_DEFAULT_DROP | GTK_DEST_DEFAULT_MOTION,
- target_table, n_targets,
+ target_table, G_N_ELEMENTS (target_table),
GDK_ACTION_COPY | GDK_ACTION_MOVE);
text_view->virtual_cursor_x = -1;
event->x + text_view->xoffset,
event->y + text_view->yoffset);
- gtk_text_buffer_paste_primary_selection (text_view->buffer,
- &iter,
- event->time,
- TRUE,
- text_view->editable);
+ gtk_text_buffer_paste_primary (text_view->buffer,
+ &iter,
+ text_view->editable);
return TRUE;
}
else if (event->button == 3)
}
static void
-gtk_text_view_move_insert (GtkTextView *text_view,
- GtkTextViewMovementStep step,
- gint count,
- gboolean extend_selection)
+gtk_text_view_move (GtkTextView *text_view,
+ GtkMovementStep step,
+ gint count,
+ gboolean extend_selection)
{
GtkTextIter insert;
GtkTextIter newplace;
gint cursor_x_pos = 0;
+ if (step == GTK_MOVEMENT_PAGES)
+ {
+ gtk_text_view_scroll_pages (text_view, count);
+ return;
+ }
+
gtk_text_buffer_get_iter_at_mark (text_view->buffer, &insert,
gtk_text_buffer_get_mark (text_view->buffer,
"insert"));
newplace = insert;
- if (step == GTK_TEXT_MOVEMENT_WRAPPED_LINE)
+ if (step == GTK_MOVEMENT_DISPLAY_LINES)
gtk_text_view_get_virtual_cursor_pos (text_view, &cursor_x_pos, NULL);
switch (step)
{
- case GTK_TEXT_MOVEMENT_CHAR:
+ case GTK_MOVEMENT_CHARS:
gtk_text_iter_forward_chars (&newplace, count);
break;
- case GTK_TEXT_MOVEMENT_POSITIONS:
+ case GTK_MOVEMENT_POSITIONS:
gtk_text_layout_move_iter_visually (text_view->layout,
&newplace, count);
break;
- case GTK_TEXT_MOVEMENT_WORD:
+ case GTK_MOVEMENT_WORDS:
if (count < 0)
gtk_text_iter_backward_word_starts (&newplace, -count);
else if (count > 0)
gtk_text_iter_forward_word_ends (&newplace, count);
break;
- case GTK_TEXT_MOVEMENT_WRAPPED_LINE:
+ case GTK_MOVEMENT_DISPLAY_LINES:
gtk_text_view_move_iter_by_lines (text_view, &newplace, count);
gtk_text_layout_move_iter_to_x (text_view->layout, &newplace, cursor_x_pos);
break;
- case GTK_TEXT_MOVEMENT_LINE:
+ case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
+ if (count > 1)
+ gtk_text_view_move_iter_by_lines (text_view, &newplace, --count);
+ else if (count < -1)
+ gtk_text_view_move_iter_by_lines (text_view, &newplace, ++count);
+
+ if (count != 0)
+ gtk_text_layout_move_iter_to_line_end (text_view->layout, &newplace, count);
+ break;
+
+ case GTK_MOVEMENT_PARAGRAPHS:
/* This should almost certainly instead be doing the parallel thing to WORD */
/* gtk_text_iter_down_lines (&newplace, count); */
/* FIXME */
break;
- case GTK_TEXT_MOVEMENT_LINE_ENDS:
+ case GTK_MOVEMENT_PARAGRAPH_ENDS:
if (count > 0)
gtk_text_iter_forward_to_newline (&newplace);
else if (count < 0)
gtk_text_iter_set_line_offset (&newplace, 0);
break;
- case GTK_TEXT_MOVEMENT_BUFFER_ENDS:
+ case GTK_MOVEMENT_BUFFER_ENDS:
if (count > 0)
gtk_text_buffer_get_last_iter (text_view->buffer, &newplace);
else if (count < 0)
gtk_text_buffer_get_mark (text_view->buffer,
"insert"), 0);
- if (step == GTK_TEXT_MOVEMENT_WRAPPED_LINE)
+ if (step == GTK_MOVEMENT_DISPLAY_LINES)
{
gtk_text_view_set_virtual_cursor_pos (text_view, cursor_x_pos, -1);
}
}
static void
-gtk_text_view_scroll_text (GtkTextView *text_view,
- GtkTextViewScrollType type)
+gtk_text_view_scroll_pages (GtkTextView *text_view,
+ gint count)
{
gfloat newval;
GtkAdjustment *adj;
/* Validate the region that will be brought into view by the cursor motion
*/
- switch (type)
+ if (count < 0)
{
- default:
- case GTK_TEXT_SCROLL_TO_TOP:
- gtk_text_buffer_get_iter_at_offset (text_view->buffer, &anchor, 0);
- y0 = 0;
- y1 = adj->page_size;
- break;
-
- case GTK_TEXT_SCROLL_TO_BOTTOM:
- gtk_text_buffer_get_last_iter (text_view->buffer, &anchor);
- y0 = -adj->page_size;
- y1 = adj->page_size;
- break;
-
- case GTK_TEXT_SCROLL_PAGE_DOWN:
gtk_text_view_get_first_para_iter (text_view, &anchor);
y0 = adj->page_size;
- y1 = adj->page_size + adj->page_increment;
- break;
-
- case GTK_TEXT_SCROLL_PAGE_UP:
+ y1 = adj->page_size + count * adj->page_increment;
+ }
+ else
+ {
gtk_text_view_get_first_para_iter (text_view, &anchor);
- y0 = - adj->page_increment + adj->page_size;
+ y0 = count * adj->page_increment + adj->page_size;
y1 = 0;
- break;
}
+
gtk_text_layout_validate_yrange (text_view->layout, &anchor, y0, y1);
gtk_text_view_get_virtual_cursor_pos (text_view, &cursor_x_pos, &cursor_y_pos);
newval = adj->value;
- switch (type)
- {
- case GTK_TEXT_SCROLL_TO_TOP:
- newval = adj->lower;
- break;
-
- case GTK_TEXT_SCROLL_TO_BOTTOM:
- newval = adj->upper;
- break;
-
- case GTK_TEXT_SCROLL_PAGE_DOWN:
- newval += adj->page_increment;
- break;
-
- case GTK_TEXT_SCROLL_PAGE_UP:
- newval -= adj->page_increment;
- break;
-
- default:
- break;
- }
+ newval += count * adj->page_increment;
cursor_y_pos += newval - adj->value;
set_adjustment_clamped (adj, newval);
}
static void
-gtk_text_view_delete_text (GtkTextView *text_view,
- GtkTextViewDeleteType type,
- gint count)
+gtk_text_view_insert (GtkTextView *text_view,
+ const gchar *str)
+{
+ gtk_text_buffer_insert_interactive_at_cursor (text_view->buffer, str, -1,
+ text_view->editable);
+}
+
+static void
+gtk_text_view_delete (GtkTextView *text_view,
+ GtkDeleteType type,
+ gint count)
{
GtkTextIter insert;
GtkTextIter start;
GtkTextIter end;
gboolean leave_one = FALSE;
- if (type == GTK_TEXT_DELETE_CHAR)
+ if (type == GTK_DELETE_CHARS)
{
/* Char delete deletes the selection, if one exists */
if (gtk_text_buffer_delete_selection (text_view->buffer, TRUE,
switch (type)
{
- case GTK_TEXT_DELETE_CHAR:
+ case GTK_DELETE_CHARS:
gtk_text_iter_forward_chars (&end, count);
break;
- case GTK_TEXT_DELETE_HALF_WORD:
+ case GTK_DELETE_WORD_ENDS:
if (count > 0)
gtk_text_iter_forward_word_ends (&end, count);
else if (count < 0)
gtk_text_iter_backward_word_starts (&start, 0 - count);
break;
- case GTK_TEXT_DELETE_WHOLE_WORD:
+ case GTK_DELETE_WORDS:
break;
- case GTK_TEXT_DELETE_HALF_WRAPPED_LINE:
+ case GTK_DELETE_DISPLAY_LINE_ENDS:
break;
- case GTK_TEXT_DELETE_WHOLE_WRAPPED_LINE:
+ case GTK_DELETE_DISPLAY_LINES:
break;
- case GTK_TEXT_DELETE_HALF_LINE:
+ case GTK_DELETE_PARAGRAPH_ENDS:
while (count > 0)
{
if (!gtk_text_iter_forward_to_newline (&end))
and support that */
break;
- case GTK_TEXT_DELETE_WHOLE_LINE:
+ case GTK_DELETE_PARAGRAPHS:
if (count > 0)
{
gtk_text_iter_set_line_offset (&start, 0);
break;
- case GTK_TEXT_DELETE_WHITESPACE_LEAVE_ONE:
- leave_one = TRUE; /* FALL THRU */
- case GTK_TEXT_DELETE_WHITESPACE:
+ case GTK_DELETE_WHITESPACE:
{
find_whitepace_region (&insert, &start, &end);
}
}
static void
-gtk_text_view_cut_text (GtkTextView *text_view)
+gtk_text_view_cut_clipboard (GtkTextView *text_view)
{
- gtk_text_buffer_cut (text_view->buffer, GDK_CURRENT_TIME, TRUE, text_view->editable);
+ gtk_text_buffer_cut_clipboard (text_view->buffer, text_view->editable);
gtk_text_view_scroll_to_mark (text_view,
gtk_text_buffer_get_mark (text_view->buffer,
"insert"),
}
static void
-gtk_text_view_copy_text (GtkTextView *text_view)
+gtk_text_view_copy_clipboard (GtkTextView *text_view)
{
- gtk_text_buffer_copy (text_view->buffer, GDK_CURRENT_TIME);
+ gtk_text_buffer_copy_clipboard (text_view->buffer);
gtk_text_view_scroll_to_mark (text_view,
gtk_text_buffer_get_mark (text_view->buffer,
"insert"),
}
static void
-gtk_text_view_paste_text (GtkTextView *text_view)
+gtk_text_view_paste_clipboard (GtkTextView *text_view)
{
- gtk_text_buffer_paste_clipboard (text_view->buffer, GDK_CURRENT_TIME, TRUE, text_view->editable);
+ gtk_text_buffer_paste_clipboard (text_view->buffer, text_view->editable);
gtk_text_view_scroll_to_mark (text_view,
gtk_text_buffer_get_mark (text_view->buffer,
"insert"),
GdkDragContext *context;
GtkTargetList *target_list;
- /* FIXME we have to handle more formats for the selection,
- and do the conversions to/from UTF8 */
-
- /* FIXME not sure how this is memory-managed. */
- target_list = gtk_target_list_new (target_table, n_targets);
-
+ target_list = gtk_target_list_new (target_table, G_N_ELEMENTS (target_table));
+
context = gtk_drag_begin (GTK_WIDGET (text_view), target_list,
GDK_ACTION_COPY | GDK_ACTION_MOVE,
1, (GdkEvent*)event);
+ gtk_target_list_unref (target_list);
+
gtk_drag_set_icon_default (context);
/* We're inside the selection, so start without being able
if (str)
{
- if (info == TARGET_UTF8_STRING)
- {
- /* Pass raw UTF8 */
- gtk_selection_data_set (selection_data,
- utf8_atom,
- 8*sizeof (gchar), (guchar *)str, length);
-
- }
- else if (info == TARGET_STRING ||
- info == TARGET_TEXT)
- {
- gchar *latin1;
-
- latin1 = gtk_text_utf_to_latin1(str, length);
-
- gtk_selection_data_set (selection_data,
- GDK_SELECTION_TYPE_STRING,
- 8*sizeof (gchar), latin1, strlen (latin1));
- g_free (latin1);
- }
- else if (info == TARGET_COMPOUND_TEXT)
- {
- /* FIXME convert UTF8 directly to current locale, not via
- latin1 */
-
- guchar *text;
- GdkAtom encoding;
- gint format;
- gint new_length;
- gchar *latin1;
-
- latin1 = gtk_text_utf_to_latin1(str, length);
-
- gdk_string_to_compound_text (latin1, &encoding, &format, &text, &new_length);
- gtk_selection_data_set (selection_data, encoding, format, text, new_length);
- gdk_free_compound_text (text);
-
- g_free (latin1);
- }
-
+ gtk_selection_data_set_text (selection_data, str);
g_free (str);
}
}
GtkTextIter drop_point;
GtkTextView *text_view;
GtkTextMark *drag_target_mark;
+ gchar *str;
- enum {INVALID, STRING, CTEXT, UTF8} type;
-
text_view = GTK_TEXT_VIEW (widget);
- if (selection_data->type == GDK_TARGET_STRING)
- type = STRING;
- else if (selection_data->type == ctext_atom)
- type = CTEXT;
- else if (selection_data->type == utf8_atom)
- type = UTF8;
- else
- type = INVALID;
-
- if (type == INVALID || selection_data->length < 0)
- {
- /* I think the DND code automatically tries asking
- for the various formats. */
- return;
- }
-
drag_target_mark = gtk_text_buffer_get_mark (text_view->buffer,
"__drag_target");
&drop_point,
drag_target_mark);
-
- switch (type)
+ str = gtk_selection_data_get_text (selection_data);
+ if (str)
{
- case STRING:
- {
- gchar *utf;
-
- utf = gtk_text_latin1_to_utf ((const gchar*)selection_data->data,
- selection_data->length);
- gtk_text_buffer_insert_interactive (text_view->buffer, &drop_point,
- utf, -1,
- text_view->editable);
- g_free (utf);
- }
- break;
-
- case UTF8:
- gtk_text_buffer_insert_interactive (text_view->buffer, &drop_point,
- (const gchar *)selection_data->data,
- selection_data->length,
- text_view->editable);
- break;
-
- case CTEXT:
- {
- gchar **list;
- gint count;
- gint i;
-
- count = gdk_text_property_to_text_list (selection_data->type,
- selection_data->format,
- selection_data->data,
- selection_data->length,
- &list);
- for (i=0; i<count; i++)
- {
- /* list contains stuff in our default encoding */
- gboolean free_utf = FALSE;
- gchar *utf = NULL;
- gchar *charset = NULL;
-
- if (g_get_charset (&charset))
- {
- utf = g_convert (list[i], -1,
- "UTF8", charset, NULL);
- free_utf = TRUE;
- }
- else
- utf = list[i];
-
- gtk_text_buffer_insert_interactive (text_view->buffer,
- &drop_point, utf, -1,
- text_view->editable);
-
- if (free_utf)
- g_free(utf);
- }
-
- if (count > 0)
- gdk_free_text_list (list);
- }
- break;
-
- case INVALID: /* quiet compiler */
- break;
+ gtk_text_buffer_insert_interactive (text_view->buffer,
+ &drop_point, str, -1,
+ text_view->editable);
+ g_free (str);
}
}
else
{
if (text_view->overwrite_mode)
- gtk_text_view_delete_text (text_view, GTK_TEXT_DELETE_CHAR, 1);
+ gtk_text_view_delete (text_view, GTK_DELETE_CHARS, 1);
gtk_text_buffer_insert_interactive_at_cursor (text_view->buffer, str, -1,
text_view->editable);
}
extern "C" {
#endif /* __cplusplus */
-typedef enum {
- GTK_TEXT_MOVEMENT_CHAR, /* move by forw/back chars */
- GTK_TEXT_MOVEMENT_POSITIONS, /* move by left/right chars */
- GTK_TEXT_MOVEMENT_WORD, /* move by forward/back words */
- GTK_TEXT_MOVEMENT_WRAPPED_LINE, /* move up/down lines (wrapped lines) */
- GTK_TEXT_MOVEMENT_LINE, /* move up/down paragraphs (newline-ended lines) */
- GTK_TEXT_MOVEMENT_LINE_ENDS, /* move to either end of a paragraph */
- GTK_TEXT_MOVEMENT_BUFFER_ENDS /* move to ends of the buffer */
-} GtkTextViewMovementStep;
-
-typedef enum {
- GTK_TEXT_SCROLL_TO_TOP,
- GTK_TEXT_SCROLL_TO_BOTTOM,
- GTK_TEXT_SCROLL_PAGE_DOWN,
- GTK_TEXT_SCROLL_PAGE_UP
-} GtkTextViewScrollType;
-
-typedef enum {
- GTK_TEXT_DELETE_CHAR,
- GTK_TEXT_DELETE_HALF_WORD, /* delete only the portion of the word to the
- left/right of cursor if we're in the middle
- of a word */
- GTK_TEXT_DELETE_WHOLE_WORD,
- GTK_TEXT_DELETE_HALF_WRAPPED_LINE,
- GTK_TEXT_DELETE_WHOLE_WRAPPED_LINE,
- GTK_TEXT_DELETE_HALF_LINE, /* like C-k in Emacs (or its reverse) */
- GTK_TEXT_DELETE_WHOLE_LINE, /* C-k in pico, kill whole line */
- GTK_TEXT_DELETE_WHITESPACE, /* M-\ in Emacs */
- GTK_TEXT_DELETE_WHITESPACE_LEAVE_ONE /* M-space in Emacs */
-} GtkTextViewDeleteType;
-
#define GTK_TYPE_TEXT_VIEW (gtk_text_view_get_type())
#define GTK_TEXT_VIEW(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_TEXT_VIEW, GtkTextView))
#define GTK_TEXT_VIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_VIEW, GtkTextViewClass))
/* These are all RUN_ACTION signals for keybindings */
/* move insertion point */
- void (* move_insert) (GtkTextView *text_view, GtkTextViewMovementStep step, gint count, gboolean extend_selection);
+ void (* move) (GtkTextView *text_view, GtkMovementStep step, gint count, gboolean extend_selection);
/* move the "anchor" (what Emacs calls the mark) to the cursor position */
void (* set_anchor) (GtkTextView *text_view);
- /* Scroll */
- void (* scroll_text) (GtkTextView *text_view, GtkTextViewScrollType type);
/* Deletions */
- void (* delete_text) (GtkTextView *text_view, GtkTextViewDeleteType type, gint count);
+ void (* insert) (GtkTextView *text_view, const gchar *str);
+ void (* delete) (GtkTextView *text_view, GtkDeleteType type, gint count);
/* cut copy paste */
- void (* cut_text) (GtkTextView *text_view);
- void (* copy_text) (GtkTextView *text_view);
- void (* paste_text) (GtkTextView *text_view);
+ void (* cut_clipboard) (GtkTextView *text_view);
+ void (* copy_clipboard) (GtkTextView *text_view);
+ void (* paste_clipboard) (GtkTextView *text_view);
/* overwrite */
void (* toggle_overwrite) (GtkTextView *text_view);
void (*set_scroll_adjustments) (GtkTextView *text_view,
projects / gtk4.git / commitdiff